diff --git a/decompiler/IR2/AtomicOpTypeAnalysis.cpp b/decompiler/IR2/AtomicOpTypeAnalysis.cpp index e32792be86..3001aeedcb 100644 --- a/decompiler/IR2/AtomicOpTypeAnalysis.cpp +++ b/decompiler/IR2/AtomicOpTypeAnalysis.cpp @@ -651,6 +651,17 @@ TP_Type SimpleExpression::get_type_int2(const TypeState& input, } } + if (env.version == GameVersion::Jak2 && tc(dts, TypeSpec("symbol"), arg1_type) && + !m_args[0].is_int() && is_int_or_uint(dts, arg0_type)) { + if (arg0_type.is_integer_constant(jak2::SYM_TO_STRING_OFFSET)) { + // symbol -> GOAL String + // NOTE - the offset doesn't fit in a s16, so it's loaded into a register first. + // so we expect the arg to be a variable, and the type propagation will figure out the + // integer constant. + return TP_Type::make_from_ts(dts.ts.make_pointer_typespec("string")); + } + } + if (tc(dts, TypeSpec("structure"), arg1_type) && !m_args[0].is_int() && is_int_or_uint(dts, arg0_type)) { if (arg1_type.typespec() == TypeSpec("symbol") && diff --git a/decompiler/IR2/FormExpressionAnalysis.cpp b/decompiler/IR2/FormExpressionAnalysis.cpp index 39133a1b17..ea14d18102 100644 --- a/decompiler/IR2/FormExpressionAnalysis.cpp +++ b/decompiler/IR2/FormExpressionAnalysis.cpp @@ -101,7 +101,8 @@ Form* try_cast_simplify(Form* in, if (new_type == TypeSpec("float")) { auto ic = get_goal_integer_constant(in, env); if (ic) { - ASSERT(*ic <= UINT32_MAX); + // ASSERT(*ic <= UINT32_MAX); + ASSERT((s64)*ic == (s64)(s32)*ic); float f; memcpy(&f, &ic.value(), sizeof(float)); return pool.form(f); @@ -983,7 +984,18 @@ void SimpleExpressionElement::update_from_stack_add_i(const Env& env, // try to find symbol to string stuff auto arg0_int = get_goal_integer_constant(args.at(0), env); - if (arg0_int && (*arg0_int == DECOMP_SYM_INFO_OFFSET + 4) && + u64 symbol_to_string_offset = -1; + switch(env.version) { + case GameVersion::Jak1: + symbol_to_string_offset = DECOMP_SYM_INFO_OFFSET + 4; + break; + case GameVersion::Jak2: + symbol_to_string_offset = jak2::SYM_TO_STRING_OFFSET; + break; + default: + ASSERT(false); + } + if (arg0_int && (*arg0_int == symbol_to_string_offset) && arg1_type.typespec() == TypeSpec("symbol")) { result->push_back(pool.alloc_element(args.at(1))); return; @@ -2655,23 +2667,53 @@ bool try_to_rewrite_matrix_inline_ctor(const Env& env, FormPool& pool, FormStack // zeroing the rows: std::vector write_vars; - for (int i = 0; i < 4; i++) { - auto elt = matrix_entries->at(i + 1).elt; + if (env.version == GameVersion::Jak1) { + for (int i = 0; i < 4; i++) { + auto elt = matrix_entries->at(i + 1).elt; - auto matcher = Matcher::set( - Matcher::deref(Matcher::any_reg(0), false, - {DerefTokenMatcher::string("vector"), DerefTokenMatcher::integer(i), - DerefTokenMatcher::string("quad")}), - Matcher::cast("uint128", Matcher::integer(0))); + auto matcher = Matcher::set( + Matcher::deref(Matcher::any_reg(0), false, + {DerefTokenMatcher::string("vector"), DerefTokenMatcher::integer(i), + DerefTokenMatcher::string("quad")}), + Matcher::cast("uint128", Matcher::integer(0))); - auto mr = match(matcher, elt); - if (mr.matched) { - if (var_name != env.get_variable_name(*mr.maps.regs.at(0))) { + auto mr = match(matcher, elt); + if (mr.matched) { + if (var_name != env.get_variable_name(*mr.maps.regs.at(0))) { + return false; + } + write_vars.push_back(*mr.maps.regs.at(0)); + } else { + return false; + } + } + } else { + for (int i = 0; i < 4; i++) { + auto elt = matrix_entries->at(i + 1).elt; + + Matcher matcher; + if (i == 3) { + matcher = Matcher::set(Matcher::deref(Matcher::any_reg(0), false, + {DerefTokenMatcher::string("trans"), + DerefTokenMatcher::string("quad")}), + Matcher::cast("uint128", Matcher::integer(0))); + + } else { + matcher = Matcher::set( + Matcher::deref(Matcher::any_reg(0), false, + {DerefTokenMatcher::string("quad"), DerefTokenMatcher::integer(i)}), + Matcher::cast("uint128", Matcher::integer(0))); + } + + auto mr = match(matcher, elt); + if (mr.matched) { + if (var_name != env.get_variable_name(*mr.maps.regs.at(0))) { + return false; + } + write_vars.push_back(*mr.maps.regs.at(0)); + } else { return false; } - write_vars.push_back(*mr.maps.regs.at(0)); - } else { - return false; } } diff --git a/decompiler/analysis/variable_naming.cpp b/decompiler/analysis/variable_naming.cpp index e419a92bcd..87b5863fd9 100644 --- a/decompiler/analysis/variable_naming.cpp +++ b/decompiler/analysis/variable_naming.cpp @@ -980,6 +980,14 @@ bool is_128bit(const TP_Type& type, const DecompilerTypeSystem& dts) { return false; } +bool is_float(const TP_Type& type, const DecompilerTypeSystem& dts) { + if (dts.ts.tc(TypeSpec("float"), type.typespec())) { + return true; + } + + return false; +} + void promote_register_class(const Function& func, VariableNames* result, const DecompilerTypeSystem& dts) { diff --git a/decompiler/config/jak2/all-types.gc b/decompiler/config/jak2/all-types.gc index 8a443d9534..fe92fa78d9 100644 --- a/decompiler/config/jak2/all-types.gc +++ b/decompiler/config/jak2/all-types.gc @@ -14,6 +14,7 @@ (define-extern integer type) (define-extern float type) (define-extern boolean type) ;; not actually added as a runtime type in jak2, but valid? supports it. +(define-extern uint16 type) (define-extern uint32 type) (define-extern int64 type) (define-extern uint64 type) @@ -53,6 +54,17 @@ (define-extern *listener-function* (function object)) (define-extern *enable-method-set* int) +(declare-type cpad-info basic) +(declare-type mouse-info basic) +(define-extern cpad-open (function cpad-info int cpad-info)) +(define-extern cpad-get-data (function cpad-info cpad-info)) +(define-extern scf-get-territory (function int)) ;; not actually a scf function... +(define-extern mouse-get-data (function mouse-info none)) +(define-extern file-stream-read (function file-stream pointer int int)) +(define-extern file-stream-open (function file-stream basic symbol file-stream)) +(define-extern file-stream-length (function file-stream int)) +(define-extern *kernel-boot-message* symbol) + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; gcommon ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -291,9 +303,9 @@ :flag-assert #xf0000005c (:methods (new (symbol type int) _type_ 0) - (update-rates! (_type_ float) none 9) - (advance-by! (_type_ float) none 10) - (tick! (_type_) none 11) + (update-rates! (_type_ float) float 9) + (advance-by! (_type_ float) _type_ 10) + (tick! (_type_) _type_ 11) (save! (_type_ (pointer uint64)) int 12) (load! (_type_ (pointer uint64)) int 13) (reset! (_type_) none 14) @@ -844,17 +856,6 @@ ;; vector-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| -(deftype vector (structure) - () - :method-count-assert 9 - :size-assert #x10 - :flag-assert #x900000010 - ;; Failed to read fields. - ) -|# - - (deftype bit-array (basic) ((length int32 :offset-assert 4) (allocated-length int32 :offset-assert 8) @@ -1014,6 +1015,7 @@ (x float :offset 0) (y float :offset 4) ) + :allow-misaligned :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 @@ -1613,161 +1615,202 @@ ;; quaternion ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| -(deftype quaternion (structure) - () - :method-count-assert 9 - :size-assert #x10 - :flag-assert #x900000010 - ;; Failed to read fields. - ) -|# - -;; (define-extern quaternion-axis-angle! object) ;; (function quaternion float float float float quaternion) -;; (define-extern quaternion-vector-angle! object) ;; (function quaternion vector float quaternion) -;; (define-extern vector-angle<-quaternion! object) ;; (function vector quaternion vector) -;; (define-extern quaternion-look-at! object) -;; (define-extern quaternion-zero! object) ;; (function quaternion quaternion) -;; (define-extern quaternion-identity! object) ;; (function quaternion quaternion) -;; (define-extern quaternion-i! object) ;; (function quaternion quaternion) -;; (define-extern quaternion-j! object) ;; (function quaternion quaternion) -;; (define-extern quaternion-k! object) ;; (function quaternion quaternion) -;; (define-extern quaternion-copy! object) ;; (function quaternion quaternion quaternion) -;; (define-extern quaternion-set! object) ;; (function quaternion float float float float quaternion) -;; (define-extern quaternion+! object) ;; (function quaternion quaternion quaternion quaternion) -;; (define-extern quaternion-! object) ;; (function quaternion quaternion quaternion quaternion) -;; (define-extern quaternion-negate! object) ;; (function quaternion quaternion quaternion) -;; (define-extern quaternion-conjugate! object) ;; (function quaternion quaternion quaternion) -;; (define-extern quaternion-float*! object) ;; (function quaternion quaternion float quaternion) -;; (define-extern quaternion-float/! object) ;; (function quaternion quaternion float quaternion) -;; (define-extern quaternion-norm2 object) ;; (function quaternion float) -;; (define-extern quaternion-norm object) ;; (function quaternion float) -;; (define-extern quaternion-normalize! object) ;; (function quaternion quaternion) -;; (define-extern quaternion-inverse! object) ;; (function quaternion quaternion quaternion) -;; (define-extern quaternion-dot object) ;; (function quaternion quaternion float) -;; (define-extern quaternion*! object) ;; (function quaternion quaternion quaternion quaternion) -;; (define-extern quaternion-right-mult-matrix! object) ;; (function matrix quaternion matrix) -;; (define-extern quaternion-left-mult-matrix! object) ;; (function matrix quaternion matrix) +(define-extern quaternion-axis-angle! (function quaternion float float float float quaternion)) +(define-extern quaternion-vector-angle! (function quaternion vector float quaternion)) +(define-extern vector-angle<-quaternion! (function vector quaternion vector)) +(define-extern quaternion-look-at! (function vector vector vector quaternion)) +(define-extern quaternion-zero! (function quaternion quaternion)) +(define-extern quaternion-identity! (function quaternion quaternion)) +(define-extern quaternion-i! (function quaternion quaternion)) +(define-extern quaternion-j! (function quaternion quaternion)) +(define-extern quaternion-k! (function quaternion quaternion)) +(define-extern quaternion-copy! (function quaternion quaternion quaternion)) +(define-extern quaternion-set! (function quaternion float float float float quaternion)) +(define-extern quaternion+! (function quaternion quaternion quaternion quaternion)) +(define-extern quaternion-! (function quaternion quaternion quaternion quaternion)) +(define-extern quaternion-negate! (function quaternion quaternion quaternion)) +(define-extern quaternion-conjugate! (function quaternion quaternion quaternion)) +(define-extern quaternion-float*! (function quaternion quaternion float quaternion)) +(define-extern quaternion-float/! (function quaternion quaternion float quaternion)) +(define-extern quaternion-norm2 (function quaternion float)) +(define-extern quaternion-norm (function quaternion float)) +(define-extern quaternion-normalize! (function quaternion quaternion)) +(define-extern quaternion-inverse! (function quaternion quaternion quaternion)) +(define-extern quaternion-dot (function quaternion quaternion float)) +(define-extern quaternion*! (function quaternion quaternion quaternion quaternion)) +(define-extern quaternion-right-mult-matrix! (function matrix quaternion matrix)) +(define-extern quaternion-left-mult-matrix! (function matrix quaternion matrix)) (define-extern quaternion->matrix (function matrix quaternion matrix)) -;; (define-extern quaternion->matrix-2 object) +(define-extern quaternion->matrix-2 (function matrix quaternion matrix)) (define-extern matrix->quaternion (function quaternion matrix quaternion)) -;; (define-extern matrix-with-scale->quaternion object) ;; (function quaternion matrix quaternion) -;; (define-extern quaternion-vector-len object) ;; (function quaternion float) -;; (define-extern quaternion-log! object) ;; (function quaternion quaternion quaternion) -;; (define-extern quaternion-exp! object) ;; (function quaternion quaternion quaternion) -;; (define-extern quaternion-slerp! object) ;; (function quaternion quaternion quaternion float quaternion) -;; (define-extern quaternion-pseudo-slerp! object) ;; (function quaternion quaternion quaternion float quaternion) -;; (define-extern quaternion-pseudo-seek object) -;; (define-extern quaternion-smooth-seek! object) -;; (define-extern quaternion-zxy! object) ;; (function quaternion vector quaternion) -;; (define-extern vector-x-quaternion! object) ;; (function vector quaternion vector) -;; (define-extern vector-y-quaternion! object) ;; (function vector quaternion vector) -;; (define-extern vector-z-quaternion! object) ;; (function vector quaternion vector) -;; (define-extern quaternion-x-angle object) -;; (define-extern quaternion-y-angle object) ;; (function quaternion float) -;; (define-extern quaternion-z-angle object) -;; (define-extern quaternion-vector-y-angle object) ;; (function quaternion vector float) -;; (define-extern quaternion-rotate-local-x! object) ;; (function quaternion quaternion float quaternion) -;; (define-extern quaternion-rotate-local-y! object) ;; (function quaternion quaternion float quaternion) -;; (define-extern quaternion-rotate-local-z! object) ;; (function quaternion quaternion float quaternion) -;; (define-extern quaternion-rotate-y! object) ;; (function quaternion quaternion float quaternion) -;; (define-extern quaternion-rotate-x! object) ;; (function quaternion quaternion float quaternion) -;; (define-extern quaternion-rotate-z! object) ;; (function quaternion quaternion float quaternion) -;; (define-extern quaternion-delta-y object) ;; (function quaternion quaternion float) -;; (define-extern quaternion-rotate-y-to-vector! object) ;; (function quaternion quaternion quaternion float quaternion) -;; (define-extern vector-rotate-x! object) -;; (define-extern vector-rotate-y! object) ;; (function vector vector float vector) -;; (define-extern vector-rotate-z! object) +(define-extern matrix-with-scale->quaternion (function quaternion matrix quaternion)) +(define-extern quaternion-vector-len (function quaternion float)) +(define-extern quaternion-log! (function quaternion quaternion quaternion)) +(define-extern quaternion-exp! (function quaternion quaternion quaternion)) +(define-extern quaternion-slerp! (function quaternion quaternion quaternion float quaternion)) +(define-extern quaternion-pseudo-slerp! (function quaternion quaternion quaternion float quaternion)) +(define-extern quaternion-pseudo-seek (function quaternion quaternion quaternion float quaternion)) +(define-extern quaternion-smooth-seek! (function quaternion quaternion quaternion float quaternion)) +(define-extern quaternion-zxy! (function quaternion vector quaternion)) +(define-extern vector-x-quaternion! (function vector quaternion vector)) +(define-extern vector-y-quaternion! (function vector quaternion vector)) +(define-extern vector-z-quaternion! (function vector quaternion vector)) +(define-extern quaternion-x-angle (function quaternion float)) +(define-extern quaternion-y-angle (function quaternion float)) +(define-extern quaternion-z-angle (function quaternion float)) +(define-extern quaternion-vector-y-angle (function quaternion vector float)) +(define-extern quaternion-rotate-local-x! (function quaternion quaternion float quaternion)) +(define-extern quaternion-rotate-local-y! (function quaternion quaternion float quaternion)) +(define-extern quaternion-rotate-local-z! (function quaternion quaternion float quaternion)) +(define-extern quaternion-rotate-y! (function quaternion quaternion float quaternion)) +(define-extern quaternion-rotate-x! (function quaternion quaternion float quaternion)) +(define-extern quaternion-rotate-z! (function quaternion quaternion float quaternion)) +(define-extern quaternion-delta-y (function quaternion quaternion float)) +(define-extern quaternion-rotate-y-to-vector! (function quaternion quaternion quaternion float quaternion)) +(define-extern vector-rotate-x! (function vector vector float vector)) +(define-extern vector-rotate-y! (function vector vector float vector)) +(define-extern vector-rotate-z! (function vector vector float vector)) (define-extern vector-y-angle (function vector float)) -;; (define-extern vector-x-angle object) ;; (function vector float) -;; (define-extern quaternion<-rotate-y-vector object) -;; (define-extern quaternion-validate object) ;; (function quaternion none) -;; (define-extern quaternion-xz-angle object) ;; (function quaternion float) +(define-extern vector-x-angle (function vector float)) +(define-extern quaternion<-rotate-y-vector (function quaternion vector quaternion)) +(define-extern quaternion-validate (function quaternion none)) +(define-extern quaternion-xz-angle (function quaternion float)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; euler ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern set-eul! object) ;; (function euler-angles float float float int euler-angles) -;; (define-extern eul->matrix object) ;; (function matrix euler-angles matrix) -;; (define-extern matrix->eul object) ;; (function euler-angles matrix int euler-angles) -;; (define-extern eul->quat object) ;; (function quaternion euler-angles quaternion) -;; (define-extern quat->eul object) ;; (function euler-angles quaternion int euler-angles) +(define-extern set-eul! (function euler-angles float float float int euler-angles)) +(define-extern eul->matrix (function matrix euler-angles matrix)) +(define-extern matrix->eul (function euler-angles matrix int euler-angles)) +(define-extern eul->quat (function quaternion euler-angles quaternion)) +(define-extern quat->eul (function euler-angles quaternion int euler-angles)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; trigonometry ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern radmod object) ;; (function float float) -;; (define-extern deg- object) ;; (function float float float) +(define-extern radmod (function float float)) +(define-extern deg- (function float float float)) (define-extern deg-diff (function float float float)) -;; (define-extern deg-seek object) ;; (function float float float float) -;; (define-extern deg-seek-smooth object) ;; (function float float float float float) -;; (define-extern deg-lerp-clamp object) ;; (function float float float float) -;; (define-extern binary-table object) ;; (array float) -;; (define-extern sincos-table object) ;; (array float) +(define-extern deg-seek (function float float float float)) +(define-extern deg-seek-smooth (function float float float float float)) +(define-extern deg-lerp-clamp (function float float float float)) +(define-extern binary-table (array float)) +(define-extern sincos-table (array float)) (define-extern sin (function float float)) -;; (define-extern sin-rad object) ;; (function float float) -;; (define-extern *sin-poly-vec* object) ;; vector -;; (define-extern *sin-poly-vec2* object) ;; vector -;; (define-extern vector-sin-rad! object) ;; (function vector vector vector) -;; (define-extern cos-rad object) ;; (function float float) -;; (define-extern *cos-poly-vec* object) ;; vector -;; (define-extern vector-cos-rad! object) ;; (function vector vector vector) -;; (define-extern vector-sincos-rad! object) ;; (function vector vector vector int) -;; (define-extern sincos-rad! object) ;; (function (pointer float) float int) -;; (define-extern sincos! object) ;; (function (pointer float) float int) -;; (define-extern vector-rad<-vector-deg! object) ;; (function vector vector none) -;; (define-extern vector-rad<-vector-deg/2! object) ;; (function vector vector int) +(define-extern sin-rad (function float float)) +(define-extern *sin-poly-vec* vector) +(define-extern *sin-poly-vec2* vector) +(define-extern vector-sin-rad! (function vector vector vector)) +(define-extern cos-rad (function float float)) +(define-extern *cos-poly-vec* vector) +(define-extern vector-cos-rad! (function vector vector vector)) +(define-extern vector-sincos-rad! (function vector vector vector int)) +(define-extern sincos-rad! (function (pointer float) float int)) +(define-extern sincos! (function (pointer float) float int)) +(define-extern vector-rad<-vector-deg! (function vector vector none)) +(define-extern vector-rad<-vector-deg/2! (function vector vector int)) (define-extern vector-sincos! (function vector vector vector int)) -;; (define-extern tan-rad object) ;; (function float float) +(define-extern tan-rad (function float float)) (define-extern cos (function float float)) -;; (define-extern tan object) ;; (function float float) -;; (define-extern atan0 object) ;; (function float float float) -;; (define-extern atan-series-rad object) ;; (function float float) -;; (define-extern atan-rad object) ;; (function float float) -;; (define-extern sign-bit object) ;; (function int int) -;; (define-extern sign-float object) -;; (define-extern sign object) ;; (function float float) -;; (define-extern atan2-rad object) ;; (function float float float) +(define-extern tan (function float float)) +(define-extern atan0 (function float float float)) +(define-extern atan-series-rad (function float float)) +(define-extern atan-rad (function float float)) +(define-extern sign-bit (function int int)) +(define-extern sign-float (function float float)) +(define-extern sign (function float float)) +(define-extern atan2-rad (function float float float)) (define-extern atan (function float float float)) -;; (define-extern asin object) ;; (function float float) -;; (define-extern acos object) ;; (function float float) -;; (define-extern acos-rad object) ;; (function float float) -;; (define-extern sinerp object) ;; (function float float float float) -;; (define-extern sinerp-clamp object) ;; (function float float float float) -;; (define-extern coserp object) ;; (function float float float float) -;; (define-extern coserp-clamp object) ;; (function float float float float) -;; (define-extern coserp180 object) ;; (function float float float float) -;; (define-extern coserp180-clamp object) ;; (function float float float float) -;; (define-extern ease-in-out object) ;; (function int int float) +(define-extern asin (function float float)) +(define-extern acos (function float float)) +(define-extern acos-rad (function float float)) +(define-extern sinerp (function float float float float)) +(define-extern sinerp-clamp (function float float float float)) +(define-extern coserp (function float float float float)) +(define-extern coserp-clamp (function float float float float)) +(define-extern coserp180 (function float float float float)) +(define-extern coserp180-clamp (function float float float float)) +(define-extern ease-in-out (function int int float)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; gsound-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| +(defenum sound-command + :type uint16 + ; (load-bank) + ; (load-music) + ; (unload-bank) + ; (play) + ; (pause-sound) + ; (stop-sound) + ; (continue-sound) + ; (set-param) + ; (set-master-volume) + ; (pause-group) + ; (stop-group) + ; (continue-group) + ; (get-irx-version) + ; (set-falloff-curve) + ; (set-sound-falloff) + ; (reload-info) + ; (set-language) + ; (set-flava) + ; (set-reverb) + ; (set-ear-trans) + ; (shutdown) + ; (list-sounds) + ; (unload-music) + ; (set-fps) + ) + +(defenum sound-group + :bitfield #t + :type uint8 + ; (sfx) + ; (music) + ; (dialog) + ; (sog3) + ; (ambient) + ; (sog5) + ; (sog6) + ; (sog7) + ) + +(defenum sound-mask + :bitfield #t + :type uint16 + ; (volume) + ; (pitch) + ; (bend) + ; (unused) + ; (time) + ; (trans) + ; (fo-min) + ; (fo-max) + ; (fo-curve) + ) + + (deftype sound-stream-name (structure) - ((name UNKNOWN 48 :offset-assert 0) + ((name uint8 48 :offset-assert 0) ) :method-count-assert 9 :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype sound-rpc-cmd (structure) - ((rsvd1 uint16 :offset-assert 0) - (command uint16 :offset-assert 2) ;; sound-command + ((rsvd1 uint16 :offset-assert 0) + (command sound-command :offset-assert 2) ) :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 ) -|# -#| (deftype sound-play-params (structure) ((mask uint16 :offset-assert 0) (pitch-mod int16 :offset-assert 2) @@ -1777,27 +1820,44 @@ (fo-curve int8 :offset-assert 10) (priority int8 :offset-assert 11) (volume int32 :offset-assert 12) - (trans UNKNOWN 3 :offset-assert 16) + (trans int32 3 :offset-assert 16) (group uint8 :offset-assert 28) - (reg UNKNOWN 3 :offset-assert 29) + (reg uint8 3 :offset-assert 29) ) + :allow-misaligned :method-count-assert 9 :size-assert #x20 :flag-assert #x900000020 ) -|# -#| +(deftype sound-name (uint128) + ((lo uint64 :offset 0) + (hi uint64 :offset 64) + ) + :flag-assert #x900000010 + ) + +(deftype sound-id (uint32) + () + (:methods + (unused-9 () none 9) + ) + :flag-assert #xa00000004 + ) + +(deftype sound-bank-id (uint32) + () + :flag-assert #x900000004 + ) + (deftype sound-rpc-bank-cmd (sound-rpc-cmd) - ((bank-name uint128 :offset-assert 16) ;; sound-name + ((bank-name sound-name :offset-assert 16) ) :method-count-assert 9 :size-assert #x20 :flag-assert #x900000020 ) -|# -#| (deftype sound-rpc-test-cmd (sound-rpc-cmd) ((ee-addr uint32 :offset-assert 4) (param0 uint16 :offset-assert 8) @@ -1806,29 +1866,23 @@ :size-assert #xa :flag-assert #x90000000a ) -|# -#| (deftype sound-rpc-sound-cmd (sound-rpc-cmd) - ((id sound-id :offset-assert 4) ;; guessed by decompiler + ((id sound-id :offset-assert 4) ) :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype sound-rpc-group-cmd (sound-rpc-cmd) - ((group uint8 :offset-assert 4) ;; sound-group + ((group sound-group :offset-assert 4) ) :method-count-assert 9 :size-assert #x5 :flag-assert #x900000005 ) -|# -#| (deftype sound-rpc-load-bank (sound-rpc-bank-cmd) ((ee-addr uint32 :offset-assert 32) ) @@ -1836,65 +1890,51 @@ :size-assert #x24 :flag-assert #x900000024 ) -|# -#| (deftype sound-rpc-load-music (sound-rpc-bank-cmd) () :method-count-assert 9 :size-assert #x20 :flag-assert #x900000020 ) -|# -#| (deftype sound-rpc-unload-bank (sound-rpc-bank-cmd) () :method-count-assert 9 :size-assert #x20 :flag-assert #x900000020 ) -|# -#| (deftype sound-rpc-play (sound-rpc-sound-cmd) - ((name uint128 :offset-assert 16) ;; sound-name + ((name sound-name :offset-assert 16) (params sound-play-params :inline :offset-assert 32) ) :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 ) -|# -#| (deftype sound-rpc-pause-sound (sound-rpc-sound-cmd) () :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype sound-rpc-stop-sound (sound-rpc-sound-cmd) () :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype sound-rpc-continue-sound (sound-rpc-sound-cmd) () :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype sound-rpc-set-param (sound-rpc-sound-cmd) ((params sound-play-params :inline :offset-assert 8) (auto-time int32 :offset-assert 40) @@ -1904,9 +1944,7 @@ :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype sound-rpc-set-master-volume (sound-rpc-group-cmd) ((volume int32 :offset-assert 8) ) @@ -1914,48 +1952,38 @@ :size-assert #xc :flag-assert #x90000000c ) -|# -#| (deftype sound-rpc-pause-group (sound-rpc-group-cmd) () :method-count-assert 9 :size-assert #x5 :flag-assert #x900000005 ) -|# -#| (deftype sound-rpc-stop-group (sound-rpc-group-cmd) () :method-count-assert 9 :size-assert #x5 :flag-assert #x900000005 ) -|# -#| (deftype sound-rpc-continue-group (sound-rpc-group-cmd) () :method-count-assert 9 :size-assert #x5 :flag-assert #x900000005 ) -|# -#| (deftype sound-rpc-get-irx-version (sound-rpc-cmd) ((major uint32 :offset-assert 4) (minor uint32 :offset-assert 8) - (ee-addr pointer :offset-assert 12) ;; guessed by decompiler + (ee-addr pointer :offset-assert 12) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype sound-rpc-set-language (sound-rpc-cmd) ((lang uint32 :offset-assert 4) ) @@ -1963,9 +1991,7 @@ :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype sound-rpc-set-stereo-mode (sound-rpc-cmd) ((mode int32 :offset-assert 4) ) @@ -1973,9 +1999,7 @@ :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype sound-rpc-set-reverb (sound-rpc-cmd) ((core uint8 :offset-assert 4) (reverb int32 :offset-assert 8) @@ -1986,22 +2010,18 @@ :size-assert #x14 :flag-assert #x900000014 ) -|# -#| (deftype sound-rpc-set-ear-trans (sound-rpc-cmd) - ((ear-trans1 UNKNOWN 3 :offset-assert 4) - (ear-trans0 UNKNOWN 3 :offset-assert 16) - (cam-trans vector3w 3 :offset-assert 28) ;; guessed by decompiler - (cam-angle int32 :offset-assert 40) + ((ear-trans1 int32 3 :offset-assert 4) + (ear-trans0 int32 3 :offset-assert 16) + (cam-trans int32 3 :offset-assert 28) + (cam-angle int32 :offset-assert 40) ) :method-count-assert 9 :size-assert #x2c :flag-assert #x90000002c ) -|# -#| (deftype sound-rpc-set-flava (sound-rpc-cmd) ((flava uint8 :offset-assert 4) (excitement uint8 :offset-assert 5) @@ -2010,9 +2030,7 @@ :size-assert #x6 :flag-assert #x900000006 ) -|# -#| (deftype sound-rpc-set-midi-reg (sound-rpc-cmd) ((reg int32 :offset-assert 4) (value int16 :offset-assert 8) @@ -2021,18 +2039,14 @@ :size-assert #xa :flag-assert #x90000000a ) -|# -#| (deftype sound-rpc-shutdown (sound-rpc-cmd) () :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 ) -|# -#| (deftype sound-rpc-set-fps (sound-rpc-cmd) ((fps uint8 :offset-assert 4) ) @@ -2040,88 +2054,89 @@ :size-assert #x5 :flag-assert #x900000005 ) -|# -#| (deftype sound-rpc-list-sounds (sound-rpc-cmd) () :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 ) -|# -#| (deftype sound-rpc-unload-music (sound-rpc-cmd) () :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 ) -|# -#| (deftype sound-rpc-union (structure) - ((data uint32 20 :offset-assert 0) ;; guessed by decompiler - (load-bank sound-rpc-load-bank :offset-assert 0) - (unload-bank sound-rpc-unload-bank :offset-assert 0) - (play sound-rpc-play :offset-assert 0) - (pause-sound sound-rpc-pause-sound :offset-assert 0) - (stop-sound sound-rpc-stop-sound :offset-assert 0) - (continue-sound sound-rpc-continue-sound :offset-assert 0) - (set-param sound-rpc-set-param :offset-assert 0) - (set-master-volume sound-rpc-set-master-volume :offset-assert 0) - (pause-group sound-rpc-pause-group :offset-assert 0) - (stop-group sound-rpc-stop-group :offset-assert 0) - (continue-group sound-rpc-continue-group :offset-assert 0) - (get-irx-version sound-rpc-get-irx-version :offset-assert 0) - (set-language sound-rpc-set-language :offset-assert 0) - (set-reverb sound-rpc-set-reverb :offset-assert 0) - (set-ear-trans sound-rpc-set-ear-trans :offset-assert 0) - (set-flava sound-rpc-set-flava :offset-assert 0) - (set-midi-reg sound-rpc-set-midi-reg :offset-assert 0) - (set-fps sound-rpc-set-fps :offset-assert 0) - (shutdown sound-rpc-shutdown :offset-assert 0) - (list-sounds sound-rpc-list-sounds :offset-assert 0) - (unload-music sound-rpc-unload-music :offset-assert 0) + ((data uint32 20 :offset-assert 0) + (load-bank sound-rpc-load-bank :offset 0) + (unload-bank sound-rpc-unload-bank :offset 0) + (play sound-rpc-play :offset 0) + (pause-sound sound-rpc-pause-sound :offset 0) + (stop-sound sound-rpc-stop-sound :offset 0) + (continue-sound sound-rpc-continue-sound :offset 0) + (set-param sound-rpc-set-param :offset 0) + (set-master-volume sound-rpc-set-master-volume :offset 0) + (pause-group sound-rpc-pause-group :offset 0) + (stop-group sound-rpc-stop-group :offset 0) + (continue-group sound-rpc-continue-group :offset 0) + (get-irx-version sound-rpc-get-irx-version :offset 0) + (set-language sound-rpc-set-language :offset 0) + (set-reverb sound-rpc-set-reverb :offset 0) + (set-ear-trans sound-rpc-set-ear-trans :offset 0) + (set-flava sound-rpc-set-flava :offset 0) + (set-midi-reg sound-rpc-set-midi-reg :offset 0) + (set-fps sound-rpc-set-fps :offset 0) + (shutdown sound-rpc-shutdown :offset 0) + (list-sounds sound-rpc-list-sounds :offset 0) + (unload-music sound-rpc-unload-music :offset 0) ) :method-count-assert 9 :size-assert #x50 :flag-assert #x900000050 ) -|# -#| (deftype sound-spec (basic) - ((mask uint16 :offset-assert 4) ;; sound-mask - (num float :offset-assert 8) - (group uint8 :offset-assert 12) ;; sound-group - (reg UNKNOWN 3 :offset-assert 13) + ((mask sound-mask :offset-assert 4) + (num float :offset-assert 8) + (group sound-group :offset-assert 12) + (reg uint8 3 :offset-assert 13) + (sound-name-char uint8 16 :offset-assert 16) + (sound-name sound-name :offset 16) + (trans int32 4 :offset-assert 32) + (volume int32 :offset-assert 48) + (pitch-mod int32 :offset-assert 52) + (bend int32 :offset-assert 56) + (fo-min int16 :offset-assert 60) + (fo-max int16 :offset-assert 62) + (fo-curve int8 :offset-assert 64) + (priority int8 :offset-assert 65) + (auto-time int32 :offset-assert 68) + (auto-from int32 :offset-assert 72) ) :method-count-assert 9 :size-assert #x4c :flag-assert #x90000004c - ;; Failed to read some fields. ) -|# -#| (deftype ambient-sound (basic) - ((spec sound-spec :offset-assert 4) ;; guessed by decompiler - (playing-id sound-id :offset-assert 8) ;; guessed by decompiler + ((spec sound-spec :offset-assert 4) + (playing-id sound-id :offset-assert 8) (trans vector :inline :offset-assert 16) - (name uint128 :offset-assert 32) ;; sound-name - (play-time uint64 :offset-assert 48) ;; time-frame - (time-base uint64 :offset-assert 56) ;; time-frame - (time-random uint64 :offset-assert 64) ;; time-frame + (name sound-name :offset-assert 32) + (play-time time-frame :offset-assert 48) + (time-base time-frame :offset-assert 56) + (time-random time-frame :offset-assert 64) (volume int32 :offset-assert 72) (pitch int32 :offset-assert 76) (falloff-near int32 :offset-assert 80) (falloff-far int32 :offset-assert 84) (falloff-mode int32 :offset-assert 88) - (params (pointer float) :offset-assert 92) ;; guessed by decompiler + (params (pointer float) :offset-assert 92) (param-count int32 :offset-assert 96) - (entity entity :offset-assert 100) ;; guessed by decompiler + (entity entity :offset-assert 100) (sound-count int32 :offset-assert 104) ) :method-count-assert 16 @@ -2138,9 +2153,8 @@ (dummy-15 () none 15) ) ) -|# -;; (define-extern *current-sound-id* object) ;; sound-id +(define-extern *current-sound-id* sound-id) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; timer-h ;; @@ -2211,125 +2225,168 @@ ;; vif-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype vif-stat (uint32) - () + ((vps uint8 :offset 0 :size 2) + (vew uint8 :offset 2 :size 1) + (mrk uint8 :offset 6 :size 1) + (vss uint8 :offset 8 :size 1) + (vfs uint8 :offset 9 :size 1) + (vis uint8 :offset 10 :size 1) + (int uint8 :offset 11 :size 1) + (er0 uint8 :offset 12 :size 1) + (er1 uint8 :offset 13 :size 1) + (fqc uint8 :offset 24 :size 4) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype vif-fbrst (uint32) + ((rst uint8 :offset 0 :size 1) + (fbk uint8 :offset 1 :size 1) + (stp uint8 :offset 2 :size 1) + (stc uint8 :offset 3 :size 1) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype vif-err (uint32) + ((mii uint8 :offset 0 :size 1) + (me0 uint8 :offset 1 :size 1) ;; PS2 hardware bug, must set this to 1 for correct operation. + (me1 uint8 :offset 2 :size 1) + ) :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 - ;; Failed to read some fields. ) -|# -#| (deftype vif-bank (structure) - ((stat uint32 :offset-assert 0) - (fbrst uint32 :offset-assert 16) - (err vif-err :offset-assert 32) ;; guessed by decompiler - (mark uint32 :offset-assert 48) - (cycle uint32 :offset-assert 64) - (mode uint32 :offset-assert 80) - (num uint32 :offset-assert 96) - (mask uint32 :offset-assert 112) - (code uint32 :offset-assert 128) - (itops uint32 :offset-assert 144) - (base uint32 :offset-assert 160) - (offset uint32 :offset-assert 176) - (tops uint32 :offset-assert 192) - (itop uint32 :offset-assert 208) - (top uint32 :offset-assert 224) - (r0 uint32 :offset-assert 256) - (r1 uint32 :offset-assert 272) - (r2 uint32 :offset-assert 288) - (r3 uint32 :offset-assert 304) - (c0 uint32 :offset-assert 320) - (c1 uint32 :offset-assert 336) - (c2 uint32 :offset-assert 352) - (c3 uint32 :offset-assert 368) + ((stat uint32 :offset-assert 0) + (fbrst uint32 :offset 16) + (err vif-err :offset 32) + (mark uint32 :offset 48) + (cycle uint32 :offset 64) + (mode uint32 :offset 80) + (num uint32 :offset 96) + (mask uint32 :offset 112) + (code uint32 :offset 128) + (itops uint32 :offset 144) + (base uint32 :offset 160) + (offset uint32 :offset 176) + (tops uint32 :offset 192) + (itop uint32 :offset 208) + (top uint32 :offset 224) + (r0 uint32 :offset 256) + (r1 uint32 :offset 272) + (r2 uint32 :offset 288) + (r3 uint32 :offset 304) + (c0 uint32 :offset 320) + (c1 uint32 :offset 336) + (c2 uint32 :offset 352) + (c3 uint32 :offset 368) ) :method-count-assert 9 :size-assert #x174 :flag-assert #x900000174 ) -|# - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; dma-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype dma-chcr (uint32) - () + ((dir uint8 :offset 0 :size 1) ;; 1 - from memory + (mod uint8 :offset 2 :size 2) ;; normal, chain, interleave + (asp uint8 :offset 4 :size 2) ;; none, 1, 2 + (tte uint8 :offset 6 :size 1) ;; transfer tag (sc only) + (tie uint8 :offset 7 :size 1) ;; tag interrupt + (str uint8 :offset 8 :size 1) ;; start! + (tag uint16 :offset 16) + ) :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 - ;; Failed to read some fields. ) -|# -#| (deftype dma-bank (structure) - ((chcr dma-chcr :offset-assert 0) ;; guessed by decompiler - (madr uint32 :offset-assert 16) - (qwc uint32 :offset-assert 32) + ((chcr dma-chcr :offset 0) + (madr uint32 :offset 16) + (qwc uint32 :offset 32) ) :method-count-assert 9 :size-assert #x24 :flag-assert #x900000024 ) -|# -#| (deftype dma-bank-source (dma-bank) - ((tadr uint32 :offset-assert 48) + ((tadr uint32 :offset 48) ) :method-count-assert 9 :size-assert #x34 :flag-assert #x900000034 ) -|# -#| (deftype dma-bank-vif (dma-bank-source) - ((as0 uint32 :offset-assert 64) - (as1 uint32 :offset-assert 80) + ((as0 uint32 :offset 64) + (as1 uint32 :offset 80) ) :method-count-assert 9 :size-assert #x54 :flag-assert #x900000054 ) -|# -#| (deftype dma-bank-spr (dma-bank-source) - ((sadr uint32 :offset-assert 128) + ((sadr uint32 :offset 128) ) :method-count-assert 9 :size-assert #x84 :flag-assert #x900000084 ) -|# -#| +(deftype dma-ctrl (uint32) + ((dmae uint8 :offset 0 :size 1) + (rele uint8 :offset 1 :size 1) + (mfd uint8 :offset 2 :size 2) + (sts uint8 :offset 4 :size 2) + (std uint8 :offset 6 :size 2) + (rcyc uint8 :offset 8 :size 3) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype dma-enable (uint32) + ((cpnd uint8 :offset 16 :size 1)) + :flag-assert #x900000004 + ) + +(deftype dma-sqwc (uint32) + ((sqwc uint8 :offset 0 :size 8) + (tqwc uint8 :offset 16 :size 8) + ) + :flag-assert #x900000004 + ) + (deftype dma-bank-control (structure) - ((ctrl dma-ctrl :offset-assert 0) ;; guessed by decompiler - (stat uint32 :offset-assert 16) - (pcr uint32 :offset-assert 32) - (sqwc dma-sqwc :offset-assert 48) ;; guessed by decompiler - (rbsr uint32 :offset-assert 64) - (rbor uint32 :offset-assert 80) - (stadr uint32 :offset-assert 96) - (enabler uint32 :offset-assert 5408) - (enablew uint32 :offset-assert 5520) + ((ctrl dma-ctrl :offset 0) + (stat uint32 :offset 16) + (pcr uint32 :offset 32) + (sqwc dma-sqwc :offset 48) + (rbsr uint32 :offset 64) + (rbor uint32 :offset 80) + (stadr uint32 :offset 96) + (enabler uint32 :offset 5408) + (enablew uint32 :offset 5520) ) :method-count-assert 9 :size-assert #x1594 :flag-assert #x900001594 ) -|# -#| (deftype vu-code-block (basic) ((name basic :offset-assert 4) (code uint32 :offset-assert 8) @@ -2340,7 +2397,12 @@ :size-assert #x14 :flag-assert #x900000014 ) -|# + + +(deftype vu-stat (uint64) + () + :flag-assert #x900000008 + ) (defenum dma-tag-id :bitfield #f @@ -2432,6 +2494,42 @@ :copy-entries vif-cmd ) +(deftype vif-mask (uint32) + ((m0 uint8 :offset 0 :size 2) + (m1 uint8 :offset 2 :size 2) + (m2 uint8 :offset 4 :size 2) + (m3 uint8 :offset 6 :size 2) + (m4 uint8 :offset 8 :size 2) + (m5 uint8 :offset 10 :size 2) + (m6 uint8 :offset 12 :size 2) + (m7 uint8 :offset 14 :size 2) + (m8 uint8 :offset 16 :size 2) + (m9 uint8 :offset 18 :size 2) + (m10 uint8 :offset 20 :size 2) + (m11 uint8 :offset 22 :size 2) + (m12 uint8 :offset 24 :size 2) + (m13 uint8 :offset 26 :size 2) + (m14 uint8 :offset 28 :size 2) + (m15 uint8 :offset 30 :size 2) + ) + :flag-assert #x900000004 + ) + +(deftype vif-stcycl-imm (uint16) + ((cl uint8 :offset 0 :size 8) + (wl uint8 :offset 8 :size 8) + ) + :flag-assert #x900000002 + ) + +(deftype vif-unpack-imm (uint16) + ((addr uint16 :offset 0 :size 10) + (usn uint8 :offset 14 :size 1) + (flg uint8 :offset 15 :size 1) + ) + :flag-assert #x900000002 + ) + (deftype vif-tag (uint32) ((imm uint16 :offset 0 :size 16) (num uint8 :offset 16 :size 8) @@ -2444,21 +2542,20 @@ :flag-assert #x900000004 ) -;; (define-extern dma-sync-fast object) ;; (function dma-bank none) -;; (define-extern dma-send-no-scratch object) ;; (function dma-bank uint32 uint32 none) -;; (define-extern dma-sync-with-count object) ;; (function dma-bank (pointer int32) int) -;; (define-extern dma-count-until-done object) ;; (function dma-bank (pointer int32) int) +(define-extern dma-sync-fast (function dma-bank none)) +(define-extern dma-send-no-scratch (function dma-bank uint32 uint32 none)) +(define-extern dma-sync-with-count (function dma-bank (pointer int32) int)) +(define-extern dma-count-until-done (function dma-bank (pointer int32) int)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; video-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype video-params (structure) ((set-video-mode basic :offset-assert 0) (reset-video-mode basic :offset-assert 4) (display-fbp int32 :offset-assert 8) - (relative-x-scale float :offset-assert 16) + (relative-x-scale float :offset 16) (display-dx int32 :offset-assert 20) (display-dy int32 :offset-assert 24) (display-sy int32 :offset-assert 28) @@ -2469,39 +2566,405 @@ :size-assert #x28 :flag-assert #x900000028 ) -|# -;; (define-extern *video-params* object) +(define-extern *video-params* video-params) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; vu1-user-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| +(defenum bucket-id + :type int32 + :bitfield #f + (bucket-0 0) + (bucket-1 1) + (bucket-2 2) + (bucket-3 3) + (bucket-4 4) + (bucket-5 5) + (bucket-6 6) + (bucket-7 7) ;; level 0 tex + (bucket-8 8) + (bucket-9 9) + (bucket-10 10) + (bucket-11 11) + (bucket-12 12) + (bucket-13 13) + (bucket-14 14) + (bucket-15 15) + (bucket-16 16) + (bucket-17 17) + (bucket-18 18) + (bucket-19 19) + (bucket-20 20) + (bucket-21 21) + (bucket-22 22) + (bucket-23 23) + (bucket-24 24) + (bucket-25 25) + (bucket-26 26) + (bucket-27 27) + (bucket-28 28) + (bucket-29 29) + (bucket-30 30) + (bucket-31 31) + (bucket-32 32) + (bucket-33 33) + (bucket-34 34) + (bucket-35 35) + (bucket-36 36) + (bucket-37 37) + (bucket-38 38) + (bucket-39 39) + (bucket-40 40) + (bucket-41 41) + (bucket-42 42) + (bucket-43 43) + (bucket-44 44) + (bucket-45 45) + (bucket-46 46) + (bucket-47 47) + (bucket-48 48) + (bucket-49 49) + (bucket-50 50) + (bucket-51 51) + (bucket-52 52) + (bucket-53 53) + (bucket-54 54) + (bucket-55 55) + (bucket-56 56) + (bucket-57 57) + (bucket-58 58) + (bucket-59 59) + (bucket-60 60) + (bucket-61 61) + (bucket-62 62) + (bucket-63 63) + (bucket-64 64) + (bucket-65 65) + (bucket-66 66) + (bucket-67 67) + (bucket-68 68) + (bucket-69 69) + (bucket-70 70) + (bucket-71 71) + (bucket-72 72) + (bucket-73 73) + (bucket-74 74) + (bucket-75 75) + (bucket-76 76) + (bucket-77 77) + (bucket-78 78) + (bucket-79 79) + (bucket-80 80) + (bucket-81 81) + (bucket-82 82) + (bucket-83 83) + (bucket-84 84) + (bucket-85 85) + (bucket-86 86) + (bucket-87 87) + (bucket-88 88) + (bucket-89 89) + (bucket-90 90) + (bucket-91 91) + (bucket-92 92) + (bucket-93 93) + (bucket-94 94) + (bucket-95 95) + (bucket-96 96) + (bucket-97 97) + (bucket-98 98) + (bucket-99 99) + (bucket-100 100) + (bucket-101 101) + (bucket-102 102) + (bucket-103 103) + (bucket-104 104) + (bucket-105 105) + (bucket-106 106) + (bucket-107 107) + (bucket-108 108) + (bucket-109 109) + (bucket-110 110) + (bucket-111 111) + (bucket-112 112) + (bucket-113 113) + (bucket-114 114) + (bucket-115 115) + (bucket-116 116) + (bucket-117 117) + (bucket-118 118) + (bucket-119 119) + (bucket-120 120) + (bucket-121 121) + (bucket-122 122) + (bucket-123 123) + (bucket-124 124) + (bucket-125 125) + (bucket-126 126) + (bucket-127 127) + (bucket-128 128) + (bucket-129 129) + (bucket-130 130) + (bucket-131 131) + (bucket-132 132) + (bucket-133 133) + (bucket-134 134) + (bucket-135 135) + (bucket-136 136) + (bucket-137 137) + (bucket-138 138) + (bucket-139 139) + (bucket-140 140) + (bucket-141 141) + (bucket-142 142) + (bucket-143 143) + (bucket-144 144) + (bucket-145 145) + (bucket-146 146) + (bucket-147 147) + (bucket-148 148) + (bucket-149 149) + (bucket-150 150) + (bucket-151 151) + (bucket-152 152) + (bucket-153 153) + (bucket-154 154) + (bucket-155 155) + (bucket-156 156) + (bucket-157 157) + (bucket-158 158) + (bucket-159 159) + (bucket-160 160) + (bucket-161 161) + (bucket-162 162) + (bucket-163 163) + (bucket-164 164) + (bucket-165 165) + (bucket-166 166) + (bucket-167 167) + (bucket-168 168) + (bucket-169 169) + (bucket-170 170) + (bucket-171 171) + (bucket-172 172) + (bucket-173 173) + (bucket-174 174) + (bucket-175 175) + (bucket-176 176) + (bucket-177 177) + (bucket-178 178) + (bucket-179 179) + (bucket-180 180) + (bucket-181 181) + (bucket-182 182) + (bucket-183 183) + (bucket-184 184) + (bucket-185 185) + (bucket-186 186) + (bucket-187 187) + (bucket-188 188) + (bucket-189 189) + (bucket-190 190) + (bucket-191 191) + (bucket-192 192) + (bucket-193 193) + (bucket-194 194) + (bucket-195 195) + (bucket-196 196) + (bucket-197 197) + (bucket-198 198) + (bucket-199 199) + (bucket-200 200) + (bucket-201 201) + (bucket-202 202) + (bucket-203 203) + (bucket-204 204) + (bucket-205 205) + (bucket-206 206) + (bucket-207 207) + (bucket-208 208) + (bucket-209 209) + (bucket-210 210) + (bucket-211 211) + (bucket-212 212) + (bucket-213 213) + (bucket-214 214) + (bucket-215 215) + (bucket-216 216) + (bucket-217 217) + (bucket-218 218) + (bucket-219 219) + (bucket-220 220) + (bucket-221 221) + (bucket-222 222) + (bucket-223 223) + (bucket-224 224) + (bucket-225 225) + (bucket-226 226) + (bucket-227 227) + (bucket-228 228) + (bucket-229 229) + (bucket-230 230) + (bucket-231 231) + (bucket-232 232) + (bucket-233 233) + (bucket-234 234) + (bucket-235 235) + (bucket-236 236) + (bucket-237 237) + (bucket-238 238) + (bucket-239 239) + (bucket-240 240) + (bucket-241 241) + (bucket-242 242) + (bucket-243 243) + (bucket-244 244) + (bucket-245 245) + (bucket-246 246) + (bucket-247 247) + (bucket-248 248) + (bucket-249 249) + (bucket-250 250) + (bucket-251 251) + (bucket-252 252) + (bucket-253 253) + (bucket-254 254) + (bucket-255 255) + (bucket-256 256) + (bucket-257 257) + (bucket-258 258) + (bucket-259 259) + (bucket-260 260) + (bucket-261 261) + (bucket-262 262) + (bucket-263 263) + (bucket-264 264) + (bucket-265 265) + (bucket-266 266) + (bucket-267 267) + (bucket-268 268) + (bucket-269 269) + (bucket-270 270) + (bucket-271 271) + (bucket-272 272) + (bucket-273 273) + (bucket-274 274) + (bucket-275 275) + (bucket-276 276) + (bucket-277 277) + (bucket-278 278) + (bucket-279 279) + (bucket-280 280) + (bucket-281 281) + (bucket-282 282) + (bucket-283 283) + (bucket-284 284) + (bucket-285 285) + (bucket-286 286) + (bucket-287 287) + (bucket-288 288) + (bucket-289 289) + (bucket-290 290) + (bucket-291 291) + (bucket-292 292) + (bucket-293 293) + (bucket-294 294) + (bucket-295 295) + (bucket-296 296) + (bucket-297 297) + (bucket-298 298) + (bucket-299 299) + (bucket-300 300) + (bucket-301 301) + (bucket-302 302) + (bucket-303 303) + (bucket-304 304) + (bucket-305 305) + (bucket-306 306) + (bucket-307 307) + (bucket-308 308) + (bucket-309 309) + (bucket-310 310) + (bucket-311 311) + (bucket-312 312) + (bucket-313 313) + (bucket-314 314) + (bucket-315 315) + (bucket-316 316) + (bucket-317 317) + (bucket-318 318) + (bucket-319 319) + (bucket-320 320) + (bucket-321 321) + (bucket-322 322) + (bucket-323 323) + (bucket-324 324) + (debug 325) + ) + +(defenum vu1-renderer-mask + :type uint64 + :bitfield #t + (rn0) + (rn1) + (rn2) + (rn3) + (rn4) + (rn5) + (rn6) + (rn7) + (rn8) + (rn9) + (rn10) + (rn11) + (rn12) + (rn13) + (rn14) + (rn15) + (rn16) + (rn17) + (rn18) + (rn19) + (rn20) + (rn21) + (rn22) + (rn23) + (rn24) + (rn25) + (rn26) + (rn27) + (rn28) + (rn29) + (rn30) + (rn31) + (rn32) + (rn33) + (rn34) + ) + (deftype dma-foreground-sink (basic) - ((bucket int32 :offset-assert 4) ;; bucket-id - (foreground-texture-page int8 :offset-assert 8) - (foreground-texture-level int8 :offset-assert 9) - (foreground-output-bucket int8 :offset-assert 10) + ((bucket bucket-id :offset-assert 4) + (foreground-texture-page int8 :offset-assert 8) + (foreground-texture-level int8 :offset-assert 9) + (foreground-output-bucket int8 :offset-assert 10) ) :method-count-assert 9 :size-assert #xb :flag-assert #x90000000b ) -|# -#| (deftype generic-bucket-state (structure) ((gifbuf-adr uint32 :offset-assert 0) (inbuf-adr uint32 :offset-assert 4) ) + :allow-misaligned :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype generic-dma-foreground-sink (dma-foreground-sink) ((state generic-bucket-state :inline :offset-assert 12) ) @@ -2509,8 +2972,6 @@ :size-assert #x14 :flag-assert #x900000014 ) -|# - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; profile-h ;; @@ -2621,25 +3082,25 @@ ;; dma ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern dma-sync-hang object) ;; (function dma-bank none) -;; (define-extern dma-sync-crash object) ;; (function dma-bank none) -;; (define-extern dma-send object) ;; (function dma-bank uint uint none) -;; (define-extern dma-send-chain object) ;; (function dma-bank-source uint none) -;; (define-extern dma-send-chain-no-tte object) ;; (function dma-bank-source uint none) -;; (define-extern dma-send-chain-no-flush object) ;; (function dma-bank-source uint none) -;; (define-extern dma-send-to-spr object) ;; (function uint uint uint symbol none) -;; (define-extern dma-send-to-spr-no-flush object) ;; (function uint uint uint symbol none) -;; (define-extern dma-send-from-spr object) ;; (function uint uint uint symbol none) -;; (define-extern dma-send-from-spr-no-flush object) ;; (function uint uint uint symbol none) -;; (define-extern dma-initialize object) ;; (function none) -;; (define-extern clear-vu0-mem object) ;; (function none) -;; (define-extern clear-vu1-mem object) ;; (function none) -;; (define-extern dump-vu1-mem object) ;; (function none) -;; (define-extern dump-vu1-range object) ;; (function uint uint symbol) -;; (define-extern reset-vif1-path object) ;; (function none) -;; (define-extern ultimate-memcpy object) ;; (function pointer pointer uint none) -;; (define-extern symlink2 object) ;; (function none) -;; (define-extern symlink3 object) ;; (function none) +(define-extern dma-sync-hang (function dma-bank none)) +(define-extern dma-sync-crash (function dma-bank none)) +(define-extern dma-send (function dma-bank uint uint none)) +(define-extern dma-send-chain (function dma-bank-source uint none)) +(define-extern dma-send-chain-no-tte (function dma-bank-source uint none)) +(define-extern dma-send-chain-no-flush (function dma-bank-source uint none)) +(define-extern dma-send-to-spr (function uint uint uint symbol none)) +(define-extern dma-send-to-spr-no-flush (function uint uint uint symbol none)) +(define-extern dma-send-from-spr (function uint uint uint symbol none)) +(define-extern dma-send-from-spr-no-flush (function uint uint uint symbol none)) +(define-extern dma-initialize (function none)) +(define-extern clear-vu0-mem (function none)) +(define-extern clear-vu1-mem (function none)) +(define-extern dump-vu1-mem (function none)) +(define-extern dump-vu1-range (function uint uint symbol)) +(define-extern reset-vif1-path (function none)) +(define-extern ultimate-memcpy (function pointer pointer uint none)) +(define-extern symlink2 (function none)) +(define-extern symlink3 (function none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; dma-buffer ;; @@ -2657,15 +3118,13 @@ :flag-assert #x900000010 ) -#| (deftype dma-packet-array (inline-array-class) - ((data UNKNOWN :dynamic :offset-assert 16) + ((data dma-packet :inline :dynamic :offset-assert 16) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# (deftype dma-gif (structure) ((gif uint64 2 :offset-assert 0) @@ -2693,32 +3152,34 @@ (end pointer :offset-assert 12) (data uint64 1 :offset-assert 16) ) + (:methods + (new (symbol type int) _type_ 0) + ) :method-count-assert 9 :size-assert #x18 :flag-assert #x900000018 ) -;; (define-extern dma-buffer-inplace-new object) ;; (function dma-buffer int dma-buffer) -;; (define-extern dma-buffer-length object) ;; (function dma-buffer int) -;; (define-extern dma-buffer-free object) ;; (function dma-buffer int) -;; (define-extern dma-buffer-add-vu-function object) ;; (function dma-buffer vu-function int symbol) -;; (define-extern dma-buffer-send object) ;; (function dma-bank dma-buffer none) -;; (define-extern dma-buffer-send-chain object) ;; (function dma-bank-source dma-buffer none) +(define-extern dma-buffer-inplace-new (function dma-buffer int dma-buffer)) +(define-extern dma-buffer-length (function dma-buffer int)) +(define-extern dma-buffer-free (function dma-buffer int)) +(define-extern dma-buffer-add-vu-function (function dma-buffer vu-function int symbol)) +(define-extern dma-buffer-send (function dma-bank dma-buffer none)) +(define-extern dma-buffer-send-chain (function dma-bank-source dma-buffer none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; dma-bucket ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern dma-buffer-add-buckets object) ;; (function dma-buffer int (inline-array dma-bucket)) -;; (define-extern dma-buffer-patch-buckets object) ;; (function (inline-array dma-bucket) int (inline-array dma-bucket)) -;; (define-extern dma-bucket-insert-tag object) ;; (function (inline-array dma-bucket) bucket-id pointer (pointer dma-tag) pointer) +(define-extern dma-buffer-add-buckets (function dma-buffer int (inline-array dma-bucket))) +(define-extern dma-buffer-patch-buckets (function (inline-array dma-bucket) int (inline-array dma-bucket))) +(define-extern dma-bucket-insert-tag (function (inline-array dma-bucket) bucket-id pointer (pointer dma-tag) pointer)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; dma-disasm ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype vif-disasm-element (structure) ((mask uint32 :offset-assert 0) (tag vif-cmd-32 :offset-assert 4) ;; guessed by decompiler @@ -2731,20 +3192,39 @@ :size-assert #x18 :flag-assert #x900000018 ) -|# -;; (define-extern *vif-disasm-table* object) ;; (array vif-disasm-element) -;; (define-extern disasm-vif-details object) ;; (function symbol (pointer uint8) vif-cmd int symbol) -;; (define-extern disasm-vif-tag object) ;; (function (pointer vif-tag) int symbol symbol int) -;; (define-extern disasm-dma-tag object) ;; (function dma-tag symbol none) -;; (define-extern *dma-disasm* object) ;; symbol -;; (define-extern disasm-dma-list object) ;; (function dma-packet symbol symbol symbol int symbol) +(define-extern *vif-disasm-table* (array vif-disasm-element)) +(define-extern disasm-vif-details (function symbol (pointer uint8) vif-cmd int symbol)) +(define-extern disasm-vif-tag (function (pointer vif-tag) int symbol symbol int)) +(define-extern disasm-dma-tag (function dma-tag symbol none)) +(define-extern *dma-disasm* symbol) +(define-extern disasm-dma-list (function dma-packet symbol symbol symbol int symbol)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; pad ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| +(defenum pad-buttons + :bitfield #t + :type uint32 + (select 0) + (l3 1) + (r3 2) + (start 3) + (up 4) + (right 5) + (down 6) + (left 7) + (l2 8) + (r2 9) + (l1 10) + (r1 11) + (triangle 12) + (circle 13) + (x 14) + (square 15) + ) + (deftype scf-time (structure) ((stat uint8 :offset-assert 0) (second uint8 :offset-assert 1) @@ -2759,9 +3239,7 @@ :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype hw-cpad (basic) ((valid uint8 :offset-assert 4) (status uint8 :offset-assert 5) @@ -2770,16 +3248,14 @@ (righty uint8 :offset-assert 9) (leftx uint8 :offset-assert 10) (lefty uint8 :offset-assert 11) - (abutton uint8 12 :offset-assert 12) ;; guessed by decompiler - (dummy uint8 12 :offset-assert 24) ;; guessed by decompiler + (abutton uint8 12 :offset-assert 12) + (dummy uint8 12 :offset-assert 24) ) :method-count-assert 9 :size-assert #x24 :flag-assert #x900000024 ) -|# -#| (deftype cpad-info (hw-cpad) ((number int32 :offset-assert 36) (cpad-file int32 :offset-assert 40) @@ -2793,302 +3269,869 @@ (align uint8 6 :offset-assert 88) ;; guessed by decompiler (direct uint8 6 :offset-assert 94) ;; guessed by decompiler (buzz-val uint8 2 :offset-assert 100) ;; guessed by decompiler - (buzz-pause-val UNKNOWN 1 :offset-assert 102) + (buzz-pause-val uint8 1 :offset-assert 102) (buzz-pause-time uint8 :offset-assert 103) (buzz-time time-frame 2 :offset-assert 104) ;; guessed by decompiler (buzz basic :offset-assert 120) (buzz-act int32 :offset-assert 124) (change-time uint64 :offset-assert 128) ;; time-frame - (old-rightx UNKNOWN 2 :offset-assert 136) - (old-righty UNKNOWN 2 :offset-assert 138) - (old-leftx UNKNOWN 2 :offset-assert 140) - (old-lefty UNKNOWN 2 :offset-assert 142) + (old-rightx uint8 2 :offset-assert 136) + (old-righty uint8 2 :offset-assert 138) + (old-leftx uint8 2 :offset-assert 140) + (old-lefty uint8 2 :offset-assert 142) ) :method-count-assert 10 :size-assert #x90 :flag-assert #xa00000090 (:methods - ;; (new (symbol type int) _type_ 0) + (new (symbol type int) _type_ 0) (dummy-9 () none 9) ) ) -|# -#| (deftype cpad-list (basic) ((num-cpads int32 :offset-assert 4) - (cpads cpad-info 2 :offset-assert 8) ;; guessed by decompiler + (cpads cpad-info 2 :offset-assert 8) + ) + (:methods + (new (symbol type) _type_ 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype mouse-info (basic) - () + ((active symbol :offset-assert 4) + (cursor basic :offset-assert 8) + (valid symbol :offset-assert 12) + (id uint8 :offset-assert 16) + (status uint16 :offset-assert 18) + (button0 uint16 :offset-assert 20) + (deltax int8 :offset-assert 22) + (deltay int8 :offset-assert 23) + (wheel uint8 :offset-assert 24) + (change-time time-frame :offset-assert 32) + (button0-abs uint32 3 :offset-assert 40) + (button0-shadow-abs uint32 1 :offset-assert 52) + (button0-rel uint32 3 :offset-assert 56) + (pos vector 2 :inline :offset-assert 80) + (posx float :offset 80) + (posy float :offset 84) + (oldposx float :offset 96 :do-not-decompile) + (oldposy float :offset 100) + (speedx float :offset 92) + (speedy float :offset 108) + ) + (:methods + (new (symbol type) _type_ 0) + ) :method-count-assert 9 :size-assert #x70 :flag-assert #x900000070 - ;; Failed to read fields. ) -|# -;; (define-extern *cheat-mode* object) ;; symbol -;; (define-extern cpad-invalid! object) ;; (function cpad-info cpad-info) -;; (define-extern analog-input object) ;; (function int float float float float float) -;; (define-extern cpad-set-buzz! object) ;; (function cpad-info int int time-frame none) -;; (define-extern *cpad-list* object) ;; cpad-list -;; (define-extern *cpad-debug* object) ;; symbol -;; (define-extern service-cpads object) ;; (function cpad-list) -;; (define-extern buzz-stop! object) ;; (function int none) -;; (define-extern *mouse* object) -;; (define-extern service-mouse object) +(define-extern *cheat-mode* symbol) +(define-extern cpad-invalid! (function cpad-info cpad-info)) +(define-extern analog-input (function int float float float float float)) +(define-extern cpad-set-buzz! (function cpad-info int int time-frame none)) +(define-extern *cpad-list* cpad-list) +(define-extern *cpad-debug* symbol) +(define-extern service-cpads (function cpad-list)) +(define-extern buzz-stop! (function int none)) +(define-extern *mouse* mouse-info) +(define-extern service-mouse (function none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; gs ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| +(defenum gs-psm + :bitfield #f + :type uint8 + (ct32 0) + (ct24 1) + (ct16 2) + (ct16s 10) + (mt8 19) + (mt4 20) + (mt8h 27) + (mt4hl 36) + (mt4hh 44) + (mz32 48) + (mz24 49) + (mz16 50) + (mz16s 58) + ) + +(defenum gs-reg + :type uint8 + (prim 0) + (rgbaq 1) + (st 2) + (uv 3) + (xyzf2 4) + (xyz2 5) + (tex0-1 6) + (tex0-2 7) + (clamp-1 8) + (clamp-2 9) + (fog 10) + (xyzf3 12) + (xyz3 13) + (tex1-1 20) + (tex1-2 21) + (tex2-1 22) + (tex2-2 23) + (xyoffset-1 24) + (xyoffset-2 25) + (prmodecont 26) + (prmode 27) + (texclut 28) + (scanmsk 34) + (miptbp1-1 52) + (miptbp1-2 53) + (miptbp2-1 54) + (miptbp2-2 55) + (texa 59) + (fogcol 61) + (texflush 63) + (scissor-1 64) + (scissor-2 65) + (alpha-1 66) + (alpha-2 67) + (dimx 68) + (dthe 69) + (colclamp 70) + (test-1 71) + (test-2 72) + (pabe 73) + (fba-1 74) + (fba-2 75) + (frame-1 76) + (frame-2 77) + (zbuf-1 78) + (zbuf-2 79) + (bitbltbuf 80) + (trxpos 81) + (trxreg 82) + (trxdir 83) + (hwreg 84) + (signal 96) + (finish 97) + (label 98) + ) + +(defenum gs-reg64 + :type uint64 + :copy-entries gs-reg + ) + +(defenum gs-prim-type + :type uint8 + (point 0) + (line 1) + (line-strip 2) + (tri 3) + (tri-strip 4) + (tri-fan 5) + (sprite 6) + ) + + +(deftype gs-pmode (uint64) + ((en1 uint8 :offset 0 :size 1) + (en2 uint8 :offset 1 :size 1) + (crtmd uint8 :offset 2 :size 3) + (mmod uint8 :offset 5 :size 1) + (amod uint8 :offset 6 :size 1) + (slbg uint8 :offset 7 :size 1) + (alp uint8 :offset 8 :size 8) + ) + :flag-assert #x900000008 + ) + +(deftype gs-smode2 (uint64) + ((int uint8 :offset 0 :size 1) + (ffmd uint8 :offset 1 :size 1) + (dpms uint8 :offset 2 :size 2) + ) + :flag-assert #x900000008 + ) + +(deftype gs-display-fb (uint64) + ((fbp uint16 :offset 0 :size 9) + (fbw uint8 :offset 9 :size 6) + (psm gs-psm :offset 15 :size 5) + (dbx uint16 :offset 32 :size 11) + (dby uint16 :offset 43 :size 11) + ) + :flag-assert #x900000008 + ) + +;; the GS's DISPLAY registers make settings for the display position on the screen regarding +;; information on Rectangular Area Read Output Circuit n for the PCRTC. +;; write-only +(deftype gs-display (uint64) + ((dx uint16 :offset 0 :size 12) + (dy uint16 :offset 12 :size 11) + (magh uint8 :offset 23 :size 4) + (magv uint8 :offset 27 :size 2) + (dw uint16 :offset 32 :size 12) + (dh uint16 :offset 44 :size 11) + ) + :flag-assert #x900000008 + ) + +;; the GS's BGCOLOR register sets the background color of the PCRTC with RGB value. +;; write-only +(deftype gs-bgcolor (uint64) + ((r uint8 :offset 0) + (g uint8 :offset 8) + (b uint8 :offset 16) + ) + :flag-assert #x900000008 + ) + +;; the GS's CSR register sets and obtains various GS statuses. +;; read-write. the fields have different effects depending on whether they're being read from +;; or written to. +;; bits 5 and 6 (0x20 and 0x40) should be zero +(deftype gs-csr (uint64) + ((signal uint8 :offset 0 :size 1) + (finish uint8 :offset 1 :size 1) + (hsint uint8 :offset 2 :size 1) + (vsint uint8 :offset 3 :size 1) + (edwint uint8 :offset 4 :size 1) + (flush uint8 :offset 8 :size 1) + (reset uint8 :offset 9 :size 1) + (nfield uint8 :offset 12 :size 1) + (field uint8 :offset 13 :size 1) + (fifo uint8 :offset 14 :size 2) + (rev uint8 :offset 16 :size 8) + (id uint8 :offset 24 :size 8) + ) + :flag-assert #x900000008 + ) + (deftype gs-bank (structure) - ((pmode uint64 :offset-assert 0) ;; gs-pmode - (smode2 uint64 :offset-assert 32) ;; gs-smode2 - (dspfb1 uint64 :offset-assert 112) ;; gs-display-fb - (display1 uint64 :offset-assert 128) ;; gs-display - (dspfb2 uint64 :offset-assert 144) ;; gs-display-fb - (display2 uint64 :offset-assert 160) ;; gs-display - (extbuf uint64 :offset-assert 176) - (extdata uint64 :offset-assert 192) - (extwrite uint64 :offset-assert 208) - (bgcolor uint64 :offset-assert 224) ;; gs-bgcolor - (csr uint64 :offset-assert 4096) ;; gs-csr - (imr uint64 :offset-assert 4112) - (busdir uint64 :offset-assert 4160) + ((pmode gs-pmode :offset-assert 0) + (smode2 gs-smode2 :offset 32) + (dspfb1 gs-display-fb :offset 112) + (display1 gs-display :offset 128) + (dspfb2 gs-display-fb :offset 144) + (display2 gs-display :offset 160) + (extbuf uint64 :offset 176) + (extdata uint64 :offset 192) + (extwrite uint64 :offset 208) + (bgcolor gs-bgcolor :offset 224) + (csr gs-csr :offset 4096) + (imr uint64 :offset 4112) + (busdir uint64 :offset 4160) ) :method-count-assert 9 :size-assert #x1048 :flag-assert #x900001048 ) -|# -#| +(deftype gs-frame (uint64) + ((fbp uint16 :offset 0 :size 9) + (fbw uint8 :offset 16 :size 6) + (psm gs-psm :offset 24 :size 6) + (fbmsk uint32 :offset 32 :size 32) + ) + :flag-assert #x900000008 + ) + + +;; the GS's ZBUF registers make various settings regarding Z buffer. +(deftype gs-zbuf (uint64) + ((zbp uint16 :offset 0 :size 9) + (psm gs-psm :offset 24 :size 4) + (zmsk uint8 :offset 32 :size 1) + ) + :flag-assert #x900000008 + ) + +;; the GS's XYOFFSET registers set the offset value for converting from the primitive coordinate +;; system to the window coordinate system. +(deftype gs-xy-offset (uint64) + ((ofx uint16 :offset 0 :size 16) + (ofy uint16 :offset 32 :size 16) + ) + :flag-assert #x900000008 + ) + +;; the GS's SCISSOR registers specify the scissoring area. The coordinate values for +;; the upper-left/lower-right points of the enabled drawing area are specified by the window +;; coordinate system. +(deftype gs-scissor (uint64) + ((scax0 uint16 :offset 0 :size 11) + (scax1 uint16 :offset 16 :size 11) + (scay0 uint16 :offset 32 :size 11) + (scay1 uint16 :offset 48 :size 11) + ) + :flag-assert #x900000008 + ) + +;; the GS's PRMODECONT register sets whether to use primitive attributes (IIP, TME, FGE, ABE, +;; AA1, FST, CTXT, FIX) specified by the PRMODE register or the PRIM register. +(deftype gs-prmode-cont (uint64) + ((ac uint8 :offset 0 :size 1)) + :flag-assert #x900000008 + ) + +;; the GS's COLCLAMP register stores settings as to whether clamping for the RGB value of the +;; pixel is performed. +(deftype gs-color-clamp (uint64) + ((clamp uint8 :offset 0 :size 1)) + :flag-assert #x900000008 + ) + +;; the GS's DTHE register stores settings for dithering (performed/not performed). +(deftype gs-dthe (uint64) + ((dthe uint8 :offset 0 :size 1)) + :flag-assert #x900000008 + ) + +(defenum gs-atest + :type uint8 + (never 0) + (always 1) + (less 2) + (less-equal 3) + (equal 4) + (greater-equal 5) + (greater 6) + (not-equal 7) + ) +(defenum gs-ztest + :type uint8 + (never 0) + (always 1) + (greater-equal 2) + (greater 3) + ) +;; the GS's TEST register performs settings related to the pixel test. +(deftype gs-test (uint64) + ((ate uint8 :offset 0 :size 1) ;; alpha test enable + (atst gs-atest :offset 1 :size 3) ;; alpha test method + (aref uint8 :offset 4 :size 8) ;; alpha val reference + (afail uint8 :offset 12 :size 2) ;; processing method on alpha test fail + (date uint8 :offset 14 :size 1) ;; dest alpha test enable + (datm uint8 :offset 15 :size 1) ;; dest alpha test mode + (zte uint8 :offset 16 :size 1) ;; depth test enable + (ztst gs-ztest :offset 17 :size 2) ;; depth test method + ) + :flag-assert #x900000008 + ) + +(deftype gs-prim (uint64) + ((prim gs-prim-type :offset 0 :size 3) + (iip uint8 :offset 3 :size 1) + (tme uint8 :offset 4 :size 1) + (fge uint8 :offset 5 :size 1) + (abe uint8 :offset 6 :size 1) + (aa1 uint8 :offset 7 :size 1) + (fst uint8 :offset 8 :size 1) + (ctxt uint8 :offset 9 :size 1) + (fix uint8 :offset 10 :size 1) + ) + :flag-assert #x900000008 + ) + +;; gap! +;; the GS's RGBAQ register sets the RGBA value of the vertex and the Q value of the normalized +;; texture coordinates. +(deftype gs-rgbaq (uint64) + ((r uint8 :offset 0 :size 8) + (g uint8 :offset 8 :size 8) + (b uint8 :offset 16 :size 8) + (a uint8 :offset 24 :size 8) ;; 0x80 --> 1.0 + (q float :offset 32 :size 32) ;; affects some LOD behavior apparently? + ) + :flag-assert #x900000008 + ) + +;; GS XYZ registers +(deftype gs-xyz (uint64) + ((x uint16 :offset 0 :size 16) ;; Q4 fixed point + (y uint16 :offset 16 :size 16) ;; Q4 fixed point + (z uint32 :offset 32 :size 32) + ) + :flag-assert #x900000008 + ) + +;; the GS's UV register specifies the texel coordinate (UV) values of the vertex. +(deftype gs-uv (uint64) + ((u uint16 :offset 0 :size 14) ;; Q4 fixed point + (v uint16 :offset 16 :size 14) ;; Q4 fixed point + ) + :flag-assert #x900000008 + ) + +;; the GS's ST register sets the S and T values of the vertex texture coordinates. +;; The value Q is specified by the RGBAQ register. +(deftype gs-st (uint64) + ((s float :offset 0 :size 32) + (t float :offset 32 :size 32) + ) + :flag-assert #x900000008 + ) + +;; GS XYZF registers +(deftype gs-xyzf (uint64) + ((x uint16 :offset 0 :size 16) ;; Q4 fixed point + (y uint16 :offset 16 :size 16) ;; Q4 fixed point + (z uint32 :offset 32 :size 24) + (f uint8 :offset 56 :size 8) ;; fog coeff + ) + :flag-assert #x900000008 + ) + +;; the GS's TRXPOS register specifies the position and scanning direction of the rectangular area +;; in each buffer where buffer transmission is performed. +(deftype gs-trxpos (uint64) + ((ssax uint16 :offset 0 :size 11) + (ssay uint16 :offset 16 :size 11) + (dsax uint16 :offset 32 :size 11) + (dsay uint16 :offset 48 :size 11) + (dir uint8 :offset 59 :size 2) + ) + :flag-assert #x900000008 + ) + +;; the GS's TRXREG register specifies the size of the rectangular area, where the transmission +;; between buffers is implemented, in units of pixels. +;; The pixel mode must be the one set by the BITBLTBUF register. +(deftype gs-trxreg (uint64) + ((rrw uint16 :offset 0 :size 12) + (rrh uint16 :offset 32 :size 12) + ) + :flag-assert #x900000008 + ) + +;; the GS's TRXDIR register specifies the transmission direction in the transmission between +;; buffers, and activates transmission. +;; Appropriate settings must be made by the BITBLTBUF/TRXPOS/TRXREG before activating +;; the transmission. +(deftype gs-trxdir (uint64) + ((xdir uint8 :offset 0 :size 2)) + :flag-assert #x900000008 + ) + +;; the GS's BITBLTBUF register stores buffer-related settings for transmission source and +;; destination during transmission between buffers. +(deftype gs-bitbltbuf (uint64) + ((sbp uint16 :offset 0 :size 14) + (sbw uint8 :offset 16 :size 6) + (spsm uint8 :offset 24 :size 6) + (dbp uint16 :offset 32 :size 14) + (dbw uint8 :offset 48 :size 6) + (dpsm uint8 :offset 56 :size 6) + ) + :flag-assert #x900000008 + ) + +;; the GS's TEX0 registers set various kinds of information regarding the textures to be used. +(deftype gs-tex0 (uint64) + ((tbp0 uint16 :offset 0 :size 14) + (tbw uint8 :offset 14 :size 6) + (psm uint8 :offset 20 :size 6) + (tw uint8 :offset 26 :size 4) + (th uint8 :offset 30 :size 4) + (tcc uint8 :offset 34 :size 1) + (tfx uint8 :offset 35 :size 2) + (cbp uint16 :offset 37 :size 14) + (cpsm uint8 :offset 51 :size 4) + (csm uint8 :offset 55 :size 1) + (csa uint8 :offset 56 :size 5) + (cld uint8 :offset 61 :size 3) + ) + :flag-assert #x900000008 + ) + +;; the GS's TEX1 registers set information on the sampling method of the textures. +(deftype gs-tex1 (uint64) + ((lcm uint8 :offset 0 :size 1) + (mxl uint8 :offset 2 :size 3) + (mmag uint8 :offset 5 :size 1) + (mmin uint8 :offset 6 :size 3) + (mtba uint8 :offset 9 :size 1) + (l uint8 :offset 19 :size 2) + (k int16 :offset 32 :size 12) + ) + :flag-assert #x900000008 + ) + +;; the GS's TEXA register sets the Alpha value to be referred to when the Alpha value of the +;; texture is not an 8-bit value. +(deftype gs-texa (uint64) + ((ta0 uint8 :offset 0 :size 8) + (aem uint8 :offset 15 :size 1) + (ta1 uint8 :offset 32 :size 8) + ) + :flag-assert #x900000008 + ) + +;; the GS's TEXCLUT register specifies the CLUT position in the buffer when the CLUT storage mode +;; is CSM=1 (CSM2 mode). +(deftype gs-texclut (uint64) + ((cbw uint8 :offset 0 :size 6) + (cou uint8 :offset 6 :size 6) + (cov uint16 :offset 12 :size 10) + ) + :flag-assert #x900000008 + ) + +;; the GS's MIPTBP registers set the buffer pointer and buffer width of textures when performing +;; MIPMAP. +;; MIPTBP1 sets levels 1 to 3, MIPTBP2 sets levels 4 to 6. +(deftype gs-miptbp (uint64) + ((tbp1 uint16 :offset 0 :size 14) + (tbw1 uint8 :offset 14 :size 6) + (tbp2 uint16 :offset 20 :size 14) + (tbw2 uint8 :offset 34 :size 6) + (tbp3 uint16 :offset 40 :size 14) + (tbw3 uint8 :offset 54 :size 6) + ) + :flag-assert #x900000008 + ) + (deftype gs-adcmd (structure) - ((word UNKNOWN 4 :offset-assert 0) - (quad uint128 :offset-assert 0) - (data uint64 :offset-assert 0) - (cmds uint64 :offset-assert 8) - (cmd uint8 :offset-assert 8) - (x uint32 :offset-assert 0) - (y uint32 :offset-assert 4) - (z uint32 :offset-assert 8) - (w uint32 :offset-assert 12) + ((word uint32 4 :offset-assert 0) + (quad uint128 :offset 0) + (data uint64 :offset 0) + (cmds uint64 :offset 8) + (cmd uint8 :offset 8) + (x uint32 :offset 0) + (y uint32 :offset 4) + (z uint32 :offset 8) + (w uint32 :offset 12) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype gs-alpha (uint64) - () - :method-count-assert 9 - :size-assert #x8 - :flag-assert #x900000008 - ;; Failed to read some fields. + ((a uint8 :offset 0 :size 2) + (b uint8 :offset 2 :size 2) + (c uint8 :offset 4 :size 2) + (d uint8 :offset 6 :size 2) + (fix uint8 :offset 32 :size 8) + ) + :flag-assert #x900000008 + ) + +(defenum gs-tex-wrap-mode + :type uint8 + (repeat 0) + (clamp 1) + (region-clamp 2) + (region-repeat 3) + ) + +(deftype gs-clamp (uint64) + ((wms gs-tex-wrap-mode :offset 0 :size 2) + (wmt gs-tex-wrap-mode :offset 2 :size 2) + (minu uint16 :offset 4 :size 10) + (maxu uint16 :offset 14 :size 10) + (minv uint16 :offset 24 :size 10) + (maxv uint16 :offset 34 :size 10) + ) + :flag-assert #x900000008 ) -|# -#| (deftype gs-fog (uint64) - () - :method-count-assert 9 - :size-assert #x8 - :flag-assert #x900000008 - ;; Failed to read some fields. + ((f uint8 :offset 56 :size 8)) + :flag-assert #x900000008 ) -|# -#| (deftype gs-fogcol (uint64) - () - :method-count-assert 9 - :size-assert #x8 - :flag-assert #x900000008 - ;; Failed to read some fields. + ((fcr uint8 :offset 0 :size 8) + (fcg uint8 :offset 8 :size 8) + (fcb uint8 :offset 16 :size 8) + ) + :flag-assert #x900000008 + ) + +(deftype gif-ctrl (uint32) + ((rst uint8 :offset 0 :size 1) + (pse uint8 :offset 3 :size 1) + ) + :flag-assert #x900000004 + ) + +(deftype gif-mode (uint32) + ((m3r uint8 :offset 0 :size 1) + (imt uint8 :offset 2 :size 1) + ) + :flag-assert #x900000004 + ) + +(deftype gif-stat (uint32) + ((m3r uint8 :offset 0 :size 1) + (m3p uint8 :offset 1 :size 1) + (imt uint8 :offset 2 :size 1) + (pse uint8 :offset 3 :size 1) + (ip3 uint8 :offset 5 :size 1) + (p3q uint8 :offset 6 :size 1) + (p2q uint8 :offset 7 :size 1) + (p1q uint8 :offset 8 :size 1) + (oph uint8 :offset 9 :size 1) + (apath uint8 :offset 10 :size 2) + (dir uint8 :offset 12 :size 1) + (fqc uint8 :offset 24 :size 5) + ) + :flag-assert #x900000004 + ) + +(deftype gif-cnt (uint32) + ((loopcnt uint16 :offset 0 :size 15) + (regcnt uint8 :offset 16 :size 4) + (vuaddr uint16 :offset 20 :size 10) + ) + :flag-assert #x900000004 + ) + +(deftype gif-p3cnt (uint32) + ((p3cnt uint16 :offset 0 :size 15)) + :flag-assert #x900000004 + ) + +(deftype gif-p3tag (uint32) + ((loopcnt uint16 :offset 0 :size 15) + (eop uint8 :offset 15 :size 1) + ) + :flag-assert #x900000004 ) -|# -#| (deftype gif-bank (structure) - ((ctrl gif-ctrl :offset-assert 0) ;; guessed by decompiler - (mode gif-mode :offset-assert 16) ;; guessed by decompiler - (stat gif-stat :offset-assert 32) ;; guessed by decompiler - (tag0 uint32 :offset-assert 64) - (tag1 uint32 :offset-assert 80) - (tag2 uint32 :offset-assert 96) - (tag3 uint32 :offset-assert 112) - (cnt gif-cnt :offset-assert 128) ;; guessed by decompiler - (p3cnt gif-p3cnt :offset-assert 144) ;; guessed by decompiler - (p3tag gif-p3tag :offset-assert 160) ;; guessed by decompiler + ((ctrl gif-ctrl :offset 0) + (mode gif-mode :offset 16) + (stat gif-stat :offset 32) + (tag0 uint32 :offset 64) + (tag1 uint32 :offset 80) + (tag2 uint32 :offset 96) + (tag3 uint32 :offset 112) + (cnt gif-cnt :offset 128) + (p3cnt gif-p3cnt :offset 144) + (p3tag gif-p3tag :offset 160) ) :method-count-assert 9 :size-assert #xa4 :flag-assert #x9000000a4 ) -|# -#| +(deftype gif-tag-prim (uint32) + () + :flag-assert #x900000004 + ) + +(deftype gif-tag-count (uint32) + () + :flag-assert #x900000004 + ) + +(defenum gif-reg-id + :type uint8 + (prim 0) + (rgbaq 1) + (st 2) + (uv 3) + (xyzf2 4) + (xyz2 5) + (tex0-1 6) + (tex0-2 7) + (clamp-1 8) + (clamp-2 9) + (fog 10) + (xyzf3 12) + (xyz3 13) + (a+d 14) + (nop 15) + ) + +(defenum gif-flag + :type uint8 + (packed 0) + (reg-list 1) + (image 2) + (disable 3) + ) + +(deftype gif-tag64 (uint64) + ((nloop uint16 :offset 0 :size 15) + (eop uint8 :offset 15 :size 1) + (id uint16 :offset 32 :size 14) + (pre uint8 :offset 46 :size 1) + (prim gs-prim :offset 47 :size 11) + (flg gif-flag :offset 58 :size 2) + (nreg uint8 :offset 60 :size 4)) + :flag-assert #x900000008 + ) +(deftype gif-tag (uint128) + ((nloop uint16 :offset 0 :size 15) + (eop uint8 :offset 15 :size 1) + (id uint16 :offset 32 :size 14) + (pre uint8 :offset 46 :size 1) + (prim uint16 :offset 47 :size 11) + (flg gif-flag :offset 58 :size 2) + (nreg uint8 :offset 60 :size 4) + (regs0 gif-reg-id :offset 64 :size 4) + (regs1 gif-reg-id :offset 68 :size 4) + (regs2 gif-reg-id :offset 72 :size 4) + (regs3 gif-reg-id :offset 76 :size 4) + (regs4 gif-reg-id :offset 80 :size 4) + (regs5 gif-reg-id :offset 84 :size 4) + (regs6 gif-reg-id :offset 88 :size 4) + (regs7 gif-reg-id :offset 92 :size 4) + (regs8 gif-reg-id :offset 96 :size 4) + (regs9 gif-reg-id :offset 100 :size 4) + (regs10 gif-reg-id :offset 104 :size 4) + (regs11 gif-reg-id :offset 108 :size 4) + (regs12 gif-reg-id :offset 112 :size 4) + (regs13 gif-reg-id :offset 116 :size 4) + (regs14 gif-reg-id :offset 120 :size 4) + (regs15 gif-reg-id :offset 124 :size 4) + ) + :flag-assert #x900000010 + ) + +(deftype gif-tag-regs (uint64) + ((regs0 gif-reg-id :offset 0 :size 4) + (regs1 gif-reg-id :offset 4 :size 4) + (regs2 gif-reg-id :offset 8 :size 4) + (regs3 gif-reg-id :offset 12 :size 4) + (regs4 gif-reg-id :offset 16 :size 4) + (regs5 gif-reg-id :offset 20 :size 4) + (regs6 gif-reg-id :offset 24 :size 4) + (regs7 gif-reg-id :offset 28 :size 4) + (regs8 gif-reg-id :offset 32 :size 4) + (regs9 gif-reg-id :offset 36 :size 4) + (regs10 gif-reg-id :offset 40 :size 4) + (regs11 gif-reg-id :offset 44 :size 4) + (regs12 gif-reg-id :offset 48 :size 4) + (regs13 gif-reg-id :offset 52 :size 4) + (regs14 gif-reg-id :offset 56 :size 4) + (regs15 gif-reg-id :offset 60 :size 4) + ) + ) + (deftype gs-gif-tag (structure) - ((qword qword :inline :offset-assert 0) ;; uint128 - (dword uint64 2 :offset-assert 0) ;; guessed by decompiler - (word uint32 4 :offset-assert 0) ;; guessed by decompiler - (tag uint64 :offset-assert 0) ;; gif-tag64 - (regs uint64 :offset-assert 8) ;; gif-tag-regs + ((qword uint128 :offset-assert 0 :score -1) ;; is "qword" and inline? in game + + (tag gif-tag64 :offset 0) + (regs gif-tag-regs :offset 8) + + (dword uint64 2 :offset 0) + (word uint32 4 :offset 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| -(deftype gif-tag (uint128) - () - :method-count-assert 9 - :size-assert #x10 - :flag-assert #x900000010 - ;; Failed to read fields. - ) -|# - -#| (deftype gif-packet (basic) ((reg-count int32 :offset-assert 4) - (gif-tag0 uint128 :offset-assert 16) - (args uint64 1 :offset-assert 32) ;; guessed by decompiler + + (gif-tag gs-gif-tag :inline :offset-assert 16) ;; note- added + (gif-tag0 uint128 :offset 16) + (args uint64 1 :offset-assert 32) ) + (:methods + (new (symbol type int) _type_ 0) + ) :method-count-assert 9 :size-assert #x28 :flag-assert #x900000028 ) -|# -#| (deftype draw-context (basic) ((orgx int32 :offset-assert 4) (orgy int32 :offset-assert 8) (orgz int32 :offset-assert 12) (width int32 :offset-assert 16) (height int32 :offset-assert 20) + (color rgba 4 :offset-assert 24) ) + (:methods + (new (symbol type int int int int rgba) _type_ 0) + ) :method-count-assert 9 :size-assert #x28 :flag-assert #x900000028 ;; Failed to read some fields. ) -|# -#| (deftype gs-packed-rgba (vector4w) - ((r int32 :offset-assert 0) - (g int32 :offset-assert 4) - (b int32 :offset-assert 8) - (a int32 :offset-assert 12) + ((r int32 :offset 0) + (g int32 :offset 4) + (b int32 :offset 8) + (a int32 :offset 12) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype gs-packed-xyzw (vector) - ((data int32 4 :offset-assert 0) ;; guessed by decompiler - (x float :offset-assert 0) ;; int32 - (y float :offset-assert 4) ;; int32 - (z float :offset-assert 8) ;; int32 - (w float :offset-assert 12) ;; int32 - (quad uint128 :offset-assert 0) - (ix int32 :offset-assert 0) - (iy int32 :offset-assert 4) - (iz int32 :offset-assert 8) - (iw int32 :offset-assert 12) + ((ix int32 :offset 0) + (iy int32 :offset 4) + (iz int32 :offset 8) + (iw int32 :offset 12) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype gs-packed-stq (vector) - ((data float 4 :offset-assert 0) ;; guessed by decompiler - (x float :offset-assert 0) - (y float :offset-assert 4) - (z float :offset-assert 8) - (w float :offset-assert 12) - (quad uint128 :offset-assert 0) - (tex-s float :offset-assert 0) - (tex-t float :offset-assert 4) - (tex-q float :offset-assert 8) - (quad uint128 :offset-assert 0) + ((tex-s float :offset 0) + (tex-t float :offset 4) + (tex-q float :offset 8) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype gs-packed-uv (vector) - ((data UNKNOWN 4 :offset-assert 0) - (x float :offset-assert 0) - (y float :offset-assert 4) - (z float :offset-assert 8) - (w float :offset-assert 12) - (quad uint128 :offset-assert 0) - (u int16 :offset-assert 0) - (v int16 :offset-assert 4) - (quad uint128 :offset-assert 0) + ((u int16 :offset 0) + (v int16 :offset 4) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype gs-packed-gt (structure) - ((stq gs-packed-stq :inline :offset-assert 0) - (rgba gs-packed-rgba :inline :offset-assert 16) - (xyzw gs-packed-xyzw :inline :offset-assert 32) + ((stq gs-packed-stq :inline :offset 0) + (rgba gs-packed-rgba :inline :offset 16) + (xyzw gs-packed-xyzw :inline :offset 32) ) :method-count-assert 9 :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype gs-packed-gt4 (structure) - ((data gs-packed-gt 4 :offset-assert 0) ;; guessed by decompiler + ((data gs-packed-gt 4 :inline :offset-assert 0) ;; guessed by decompiler ) :method-count-assert 9 :size-assert #xc0 :flag-assert #x9000000c0 ) -|# -;; (define-extern psm-size object) ;; (function gs-psm int) -;; (define-extern psm-page-height object) ;; (function gs-psm int) -;; (define-extern psm->string object) ;; (function gs-psm string) -;; (define-extern *fog-color* object) ;; rgba -;; (define-extern open-gif-packet object) ;; (function gif-packet gif-packet) -;; (define-extern add-reg-gif-packet object) ;; (function gif-packet int int none) -;; (define-extern close-gif-packet object) ;; (function gif-packet int gif-packet) -;; (define-extern draw-context-set-xy object) ;; (function draw-context int int none) +(define-extern psm-size (function gs-psm int)) +(define-extern psm-page-height (function gs-psm int)) +(define-extern psm->string (function gs-psm string)) +(define-extern *fog-color* rgba) +(define-extern open-gif-packet (function gif-packet gif-packet)) +(define-extern add-reg-gif-packet (function gif-packet int int none)) +(define-extern close-gif-packet (function gif-packet int gif-packet)) +(define-extern draw-context-set-xy (function draw-context int int none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; display-h ;; @@ -3105,110 +4148,113 @@ (start-time uint64 :offset-assert 56) (run-time uint64 :offset-assert 64) ;; int64 ) + (:methods + (new (symbol type) _type_ 0) + ) :method-count-assert 9 :size-assert #x48 :flag-assert #x900000048 ) (deftype display (basic) - ((on-screen int32 :offset-assert 4) - (last-screen int32 :offset-assert 8) - (frames display-frame 2 :offset-assert 12) - (bgcolor uint64 :offset-assert 24) - (pmode uint64 :offset-assert 32) - (clock clock 13 :offset-assert 40) - (session-clock clock :offset 40) - (game-clock clock :offset 44) - (base-clock clock :offset 48) - (real-clock clock :offset 52) - (frame-clock clock :offset 56) - (real-frame-clock clock :offset 60) - (target-clock clock :offset 64) - (entity-clock clock :offset 68) - (part-clock clock :offset 72) - (bg-clock clock :offset 76) - (camera-clock clock :offset 80) - (user0-clock clock :offset 84) - (total-game-clock clock :offset 88) - (time-factor float :offset-assert 92) - (dog-ratio float :offset-assert 96) - (vblank-start-time uint64 2 :offset-assert 104) - (total-run-time uint64 :offset-assert 120) - (run-half-speed basic :offset-assert 128) - (dog-count float :offset-assert 132) - (vu1-enable-user uint64 :offset-assert 136) - (vu1-enable-user-menu uint64 :offset-assert 144) - (force-sync uint32 :offset-assert 152) + ((on-screen int32 :offset-assert 4) + (last-screen int32 :offset-assert 8) + (frames display-frame 2 :offset-assert 12) + (bgcolor uint64 :offset-assert 24) + (pmode gs-pmode :offset-assert 32) + (clock clock 13 :offset-assert 40) + (session-clock clock :offset 40) + (game-clock clock :offset 44) + (base-clock clock :offset 48) + (real-clock clock :offset 52) + (frame-clock clock :offset 56) + (real-frame-clock clock :offset 60) + (target-clock clock :offset 64) + (entity-clock clock :offset 68) + (part-clock clock :offset 72) + (bg-clock clock :offset 76) + (camera-clock clock :offset 80) + (user0-clock clock :offset 84) + (total-game-clock clock :offset 88) + (time-factor float :offset-assert 92) + (dog-ratio float :offset-assert 96) + (vblank-start-time uint64 2 :offset-assert 104) + (total-run-time uint64 :offset-assert 120) + (run-half-speed basic :offset-assert 128) + (dog-count float :offset-assert 132) + (vu1-enable-user vu1-renderer-mask :offset-assert 136) + (vu1-enable-user-menu vu1-renderer-mask :offset-assert 144) + (force-sync uint32 :offset-assert 152) ) :method-count-assert 10 :size-assert #x9c :flag-assert #xa0000009c (:methods - ;; (new (symbol type int int int int int) _type_ 0) + (new (symbol type int int int int int) _type_ 0) (dummy-9 () none 9) ;; (set-time-ratios (_type_ float) float 9) ) ) -;; (define-extern *pre-draw-hook* object) ;; (function object none) -;; (define-extern *post-draw-hook* object) ;; (function dma-buffer none) +(define-extern *pre-draw-hook* (function object none)) +(define-extern *post-draw-hook* (function dma-buffer none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; geometry ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern vector-flatten! object) ;; (function vector vector vector vector) -;; (define-extern vector-reflect! object) ;; (function vector vector vector vector) -;; (define-extern vector-reflect-flat! object) ;; (function vector vector vector vector) -;; (define-extern vector-reflect-flat-above! object) ;; (function vector vector vector vector) -;; (define-extern vector-reflect-flat-gravity! object) -;; (define-extern vector-segment-distance-point! object) ;; (function vector vector vector vector float) -;; (define-extern vector-line-distance object) ;; (function vector vector vector float) -;; (define-extern vector-line-distance-point! object) ;; (function vector vector vector vector float) -;; (define-extern vector-segment-overlap object) -;; (define-extern line-sphere-intersection? object) -;; (define-extern vector-orient-by-quat! object) ;; (function vector vector quaternion vector) -;; (define-extern vector-inv-orient-by-quat! object) -;; (define-extern forward-down->inv-matrix object) ;; (function matrix vector vector matrix) -;; (define-extern forward-down-nopitch->inv-matrix object) ;; (function matrix vector vector matrix) -;; (define-extern forward-up->inv-matrix object) -;; (define-extern forward-up-nopitch->inv-matrix object) ;; (function matrix vector vector matrix) -;; (define-extern forward-up-nopitch->quaternion object) ;; (function quaternion vector vector quaternion) -;; (define-extern forward-up->quaternion object) ;; (function quaternion vector vector quaternion) -;; (define-extern quaternion-from-two-vectors! object) ;; (function quaternion vector vector quaternion) -;; (define-extern quaternion-from-two-vectors-partial! object) -;; (define-extern quaternion-from-two-vectors-max-angle! object) ;; (function quaternion vector vector float quaternion) -;; (define-extern quaternion-from-two-vectors-max-angle-partial! object) -;; (define-extern matrix-from-two-vectors! object) ;; (function matrix vector vector matrix) -;; (define-extern matrix-from-two-vectors-max-angle! object) ;; (function matrix vector vector float matrix) -;; (define-extern matrix-from-two-vectors-smooth! object) -;; (define-extern matrix-from-two-vectors-the-long-way-smooth! object) -;; (define-extern quaternion-from-two-vectors-smooth! object) -;; (define-extern matrix-from-two-vectors-max-angle-partial! object) ;; (function matrix vector vector float float matrix) -;; (define-extern matrix-from-two-vectors-partial-linear! object) ;; (function matrix vector vector float matrix) -;; (define-extern matrix-remove-z-rot object) ;; (function matrix matrix matrix) -;; (define-extern matrix-rot-diff! object) ;; (function vector matrix matrix float) -;; (define-extern quaternion-seek object) ;; (function quaternion quaternion quaternion float float quaternion) -;; (define-extern vector-deg-seek object) ;; (function vector vector vector float vector) -;; (define-extern vector-deg-slerp object) ;; (function vector vector vector float vector) -;; (define-extern vector-vector-deg-slerp! object) ;; (function vector vector vector float vector vector) -;; (define-extern normal-of-plane object) ;; (function vector vector vector vector vector) -;; (define-extern vector-3pt-cross! object) ;; (function vector vector vector vector vector) -;; (define-extern closest-pt-in-triangle object) ;; (function vector vector matrix vector none) -;; (define-extern point-in-triangle-cross object) ;; (function vector vector vector vector vector symbol) -;; (define-extern point-in-plane-<-point+normal! object) ;; (function vector vector vector vector) -;; (define-extern circle-circle-xz-intersect object) ;; (function sphere sphere vector vector int) -;; (define-extern circle-test object) ;; (function none) -;; (define-extern vector-circle-tangent-new object) ;; (function vector vector vector vector none) -;; (define-extern vector-circle-tangent object) ;; (function vector vector vector vector none) -;; (define-extern find-knot-span object) ;; (function int int float (inline-array vector) int) -;; (define-extern calculate-basis-functions-vector! object) ;; (function vector int float (pointer float) vector) -;; (define-extern curve-evaluate! object) ;; (function vector float (inline-array vector) int (pointer float) int vector) -;; (define-extern curve-get-pos! object) ;; (function vector float curve vector) -;; (define-extern curve-length object) ;; (function curve float) -;; (define-extern curve-copy! object) ;; (function curve curve curve) -;; (define-extern curve-closest-point object) ;; (function curve vector float float int float float) -;; (define-extern vector-plane-distance object) ;; (function vector plane vector float) -;; (define-extern intersect-ray-plane object) +(define-extern vector-flatten! (function vector vector vector vector)) +(define-extern vector-reflect! (function vector vector vector vector)) +(define-extern vector-reflect-flat! (function vector vector vector vector)) +(define-extern vector-reflect-flat-above! (function vector vector vector vector)) +(define-extern vector-reflect-flat-gravity! (function vector vector vector vector vector)) +(define-extern vector-segment-distance-point! (function vector vector vector vector float)) +(define-extern vector-line-distance (function vector vector vector float)) +(define-extern vector-line-distance-point! (function vector vector vector vector float)) +(define-extern vector-segment-overlap (function vector vector vector float)) +(define-extern line-sphere-intersection? (function vector vector vector symbol)) +(define-extern vector-orient-by-quat! (function vector vector quaternion vector)) +(define-extern vector-inv-orient-by-quat! (function vector vector quaternion vector)) +(define-extern forward-down->inv-matrix (function matrix vector vector matrix)) +(define-extern forward-down-nopitch->inv-matrix (function matrix vector vector matrix)) +(define-extern forward-up->inv-matrix (function matrix vector vector matrix)) +(define-extern forward-up-nopitch->inv-matrix (function matrix vector vector matrix)) +(define-extern forward-up-nopitch->quaternion (function quaternion vector vector quaternion)) +(define-extern forward-up->quaternion (function quaternion vector vector quaternion)) +(define-extern quaternion-from-two-vectors! (function quaternion vector vector quaternion)) +(define-extern quaternion-from-two-vectors-partial! (function quaternion vector vector float quaternion)) +(define-extern quaternion-from-two-vectors-max-angle! (function quaternion vector vector float quaternion)) +(define-extern quaternion-from-two-vectors-max-angle-partial! (function quaternion vector vector float float quaternion)) +(define-extern matrix-from-two-vectors! (function matrix vector vector matrix)) +(define-extern matrix-from-two-vectors-max-angle! (function matrix vector vector float matrix)) +(define-extern matrix-from-two-vectors-smooth! (function matrix vector vector float int matrix)) +(define-extern matrix-from-two-vectors-the-long-way-smooth! (function matrix vector vector float int matrix)) +(define-extern quaternion-from-two-vectors-smooth! (function quaternion vector vector float int quaternion)) +(define-extern matrix-from-two-vectors-max-angle-partial! (function matrix vector vector float float matrix)) +(define-extern matrix-from-two-vectors-partial-linear! (function matrix vector vector float matrix)) +(define-extern matrix-remove-z-rot (function matrix matrix matrix)) +(define-extern matrix-rot-diff! (function vector matrix matrix float)) +(define-extern quaternion-seek (function quaternion quaternion quaternion float float quaternion)) +(define-extern vector-deg-seek (function vector vector vector float vector)) +(define-extern vector-deg-slerp (function vector vector vector float vector)) +(define-extern vector-vector-deg-slerp! (function vector vector vector float vector vector)) +(define-extern normal-of-plane (function vector vector vector vector vector)) +(define-extern vector-3pt-cross! (function vector vector vector vector vector)) +(define-extern closest-pt-in-triangle (function vector vector matrix vector none)) +(define-extern point-in-triangle-cross (function vector vector vector vector vector symbol)) +(define-extern point-in-plane-<-point+normal! (function vector vector vector vector)) +(define-extern circle-circle-xz-intersect (function sphere sphere vector vector int)) +(define-extern circle-test (function none)) +(define-extern vector-circle-tangent-new (function vector vector vector vector none)) +(define-extern vector-circle-tangent (function vector vector vector vector none)) +(define-extern find-knot-span (function int int float (inline-array vector) int)) +(define-extern calculate-basis-functions-vector! (function vector int float (pointer float) vector)) +(define-extern curve-evaluate! (function vector float (inline-array vector) int (pointer float) int vector)) +(define-extern curve-get-pos! (function vector float curve vector)) +(define-extern curve-length (function curve float)) +(define-extern curve-copy! (function curve curve curve)) +(define-extern curve-closest-point (function curve vector float float int float float)) +(define-extern vector-plane-distance (function vector plane vector float)) +(define-extern intersect-ray-plane (function vector vector vector vector float)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; timer ;; @@ -3231,114 +4277,129 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (define-extern vector-cross! (function vector vector vector vector)) -;; (define-extern vector-xz-cross! object) -;; (define-extern vector+float! object) ;; (function vector vector float vector) -;; (define-extern vector*! object) ;; (function vector vector vector vector) -;; (define-extern vector+*! object) ;; (function vector vector vector float vector) -;; (define-extern vector-*! object) ;; (function vector vector vector float vector) -;; (define-extern vector/! object) ;; (function vector vector vector vector) +(define-extern vector-xz-cross! (function vector vector vector vector)) +(define-extern vector+float! (function vector vector float vector)) +(define-extern vector*! (function vector vector vector vector)) +(define-extern vector+*! (function vector vector vector float vector)) +(define-extern vector-*! (function vector vector vector float vector)) +(define-extern vector/! (function vector vector vector vector)) (define-extern vector-float*! (function vector vector float vector)) -;; (define-extern vector-average! object) ;; (function vector vector vector vector) -;; (define-extern vector+float*! object) ;; (function vector vector vector float vector) -;; (define-extern vector--float*! object) ;; (function vector vector vector float vector) -;; (define-extern vector-float/! object) ;; (function vector vector float vector) -;; (define-extern vector-negate! object) ;; (function vector vector vector) -;; (define-extern vector-negate-in-place! object) ;; (function vector vector) -;; (define-extern vector= object) ;; (function vector vector symbol) -;; (define-extern vector-delta object) ;; (function vector vector float) -;; (define-extern vector-seek! object) ;; (function vector vector float vector) -;; (define-extern vector-smooth-seek! object) -;; (define-extern vector-seek-2d-xz-smooth! object) ;; (function vector vector float float vector) -;; (define-extern vector-seek-2d-yz-smooth! object) ;; (function vector vector float float vector) -;; (define-extern vector-seek-3d-smooth! object) ;; (function vector vector float float vector) -;; (define-extern seek-with-smooth object) ;; (function float float float float float float) +(define-extern vector-average! (function vector vector vector vector)) +(define-extern vector+float*! (function vector vector vector float vector)) +(define-extern vector--float*! (function vector vector vector float vector)) +(define-extern vector-float/! (function vector vector float vector)) +(define-extern vector-negate! (function vector vector vector)) +(define-extern vector-negate-in-place! (function vector vector)) +(define-extern vector= (function vector vector symbol)) +(define-extern vector-delta (function vector vector float)) +(define-extern vector-seek! (function vector vector float vector)) +(define-extern vector-smooth-seek! (function vector vector float vector)) +(define-extern vector-seek-2d-xz-smooth! (function vector vector float float vector)) +(define-extern vector-seek-2d-yz-smooth! (function vector vector float float vector)) +(define-extern vector-seek-3d-smooth! (function vector vector float float vector)) +(define-extern seek-with-smooth (function float float float float float float)) (define-extern vector-identity! (function vector vector)) -;; (define-extern vector-seconds object) ;; (function vector vector vector) -;; (define-extern vector-seconds! object) ;; (function vector vector) -;; (define-extern vector-v! object) ;; (function vector vector) -;; (define-extern vector-v+! object) ;; (function vector vector vector vector) -;; (define-extern vector-v*float+! object) ;; (function vector vector vector float vector) -;; (define-extern vector-v++! object) ;; (function vector vector vector) -;; (define-extern vector-v*float! object) ;; (function vector vector float vector) -;; (define-extern vector-v*float++! object) ;; (function vector vector float vector) -;; (define-extern vector-to-ups! object) ;; (function vector vector vector) -;; (define-extern vector-from-ups! object) ;; (function vector vector vector) +(define-extern vector-seconds (function vector vector vector)) +(define-extern vector-seconds! (function vector vector)) +(define-extern vector-v! (function vector vector)) +(define-extern vector-v+! (function vector vector vector vector)) +(define-extern vector-v*float+! (function vector vector vector float vector)) +(define-extern vector-v++! (function vector vector vector)) +(define-extern vector-v*float! (function vector vector float vector)) +(define-extern vector-v*float++! (function vector vector float vector)) +(define-extern vector-to-ups! (function vector vector vector)) +(define-extern vector-from-ups! (function vector vector vector)) (define-extern vector-length (function vector float)) (define-extern vector-length-squared (function vector float)) -;; (define-extern vector-xz-length-squared object) ;; (function vector float) -;; (define-extern vector-xz-length object) ;; (function vector float) -;; (define-extern vector-vector-distance object) ;; (function vector vector float) -;; (define-extern vector-vector-distance-squared object) ;; (function vector vector float) -;; (define-extern vector-vector-xz-distance object) ;; (function vector vector float) -;; (define-extern vector-vector-xy-distance object) -;; (define-extern vector-vector-xz-distance-squared object) ;; (function vector vector float) +(define-extern vector-xz-length-squared (function vector float)) +(define-extern vector-xz-length (function vector float)) +(define-extern vector-vector-distance (function vector vector float)) +(define-extern vector-vector-distance-squared (function vector vector float)) +(define-extern vector-vector-xz-distance (function vector vector float)) +(define-extern vector-vector-xy-distance (function vector vector float)) +(define-extern vector-vector-xz-distance-squared (function vector vector float)) (define-extern vector-normalize! (function vector float vector)) -;; (define-extern vector-normalize-ret-len! object) ;; (function vector float float) +(define-extern vector-normalize-ret-len! (function vector float float)) (define-extern vector-normalize-copy! (function vector vector float vector)) -;; (define-extern vector-xz-normalize! object) ;; (function vector float vector) -;; (define-extern vector-xz-normalize-copy! object) -;; (define-extern vector-length-max! object) ;; (function vector float vector) -;; (define-extern vector-xz-length-max! object) ;; (function vector float vector) -;; (define-extern vector-rotate-around-x! object) -;; (define-extern vector-rotate-around-y! object) ;; (function vector vector float vector) -;; (define-extern vector-rotate90-around-y! object) -;; (define-extern vector-rotate-around-z! object) -;; (define-extern rotate-y<-vector+vector object) ;; (function vector vector float) -;; (define-extern rotate-x<-vector+vector object) -;; (define-extern rotate-z<-vector+vector object) -;; (define-extern vector-cvt.w.s! object) ;; (function vector vector vector) -;; (define-extern vector-cvt.s.w! object) ;; (function vector vector vector) -;; (define-extern rot-zxy-from-vector! object) ;; (function vector vector vector) -;; (define-extern rot-zyx-from-vector! object) ;; (function vector vector vector) -;; (define-extern vector-lerp! object) ;; (function vector vector vector float vector) -;; (define-extern vector-lerp-clamp! object) ;; (function vector vector vector float vector) -;; (define-extern vector4-lerp! object) ;; (function vector vector vector float vector) -;; (define-extern vector4-lerp-clamp! object) ;; (function vector vector vector float vector) -;; (define-extern vector-degi object) ;; (function vector vector vector) -;; (define-extern vector-degf object) ;; (function vector vector vector) -;; (define-extern vector-degmod object) ;; (function vector vector vector) -;; (define-extern vector-deg-diff object) ;; (function vector vector vector none) -;; (define-extern vector-deg-lerp-clamp! object) ;; (function vector vector vector float vector) -;; (define-extern vector3s-copy! object) ;; (function vector vector vector) -;; (define-extern vector3s+! object) ;; (function vector vector vector vector) -;; (define-extern vector3s*float! object) ;; (function vector vector float vector) -;; (define-extern vector3s-! object) ;; (function vector vector vector vector) -;; (define-extern vector4-add! object) -;; (define-extern vector4-sub! object) -;; (define-extern vector4-mul! object) -;; (define-extern vector4-scale! object) -;; (define-extern vector4-madd! object) -;; (define-extern vector4-msub! object) -;; (define-extern vector4-array-add! object) -;; (define-extern vector4-array-sub! object) -;; (define-extern vector4-array-mul! object) -;; (define-extern vector4-array-scale! object) -;; (define-extern vector4-array-madd! object) -;; (define-extern vector4-array-msub! object) -;; (define-extern vector4-array-lerp! object) -;; (define-extern spheres-overlap? object) ;; (function sphere sphere symbol) -;; (define-extern sphere<-vector! object) ;; (function sphere vector sphere) -;; (define-extern sphere<-vector+r! object) ;; (function sphere vector float sphere) -;; (define-extern rand-vu-sphere-point! object) ;; (function vector float vector) -;; (define-extern vector-vector-angle-safe object) +(define-extern vector-xz-normalize! (function vector float vector)) +(define-extern vector-xz-normalize-copy! (function vector vector float vector)) +(define-extern vector-length-max! (function vector float vector)) +(define-extern vector-xz-length-max! (function vector float vector)) +(define-extern vector-rotate-around-x! (function vector vector float vector)) +(define-extern vector-rotate-around-y! (function vector vector float vector)) +(define-extern vector-rotate90-around-y! (function vector vector vector)) +(define-extern vector-rotate-around-z! (function vector vector float vector)) +(define-extern rotate-y<-vector+vector (function vector vector float)) +(define-extern rotate-x<-vector+vector (function vector vector float)) +(define-extern rotate-z<-vector+vector (function vector vector float)) +(define-extern vector-cvt.w.s! (function vector vector vector)) +(define-extern vector-cvt.s.w! (function vector vector vector)) +(define-extern rot-zxy-from-vector! (function vector vector vector)) +(define-extern rot-zyx-from-vector! (function vector vector vector)) +(define-extern vector-lerp! (function vector vector vector float vector)) +(define-extern vector-lerp-clamp! (function vector vector vector float vector)) +(define-extern vector4-lerp! (function vector vector vector float vector)) +(define-extern vector4-lerp-clamp! (function vector vector vector float vector)) +(define-extern vector-degi (function vector vector vector)) +(define-extern vector-degf (function vector vector vector)) +(define-extern vector-degmod (function vector vector vector)) +(define-extern vector-deg-diff (function vector vector vector none)) +(define-extern vector-deg-lerp-clamp! (function vector vector vector float vector)) +(define-extern vector3s-copy! (function vector vector vector)) +(define-extern vector3s+! (function vector vector vector vector)) +(define-extern vector3s*float! (function vector vector float vector)) +(define-extern vector3s-! (function vector vector vector vector)) +(define-extern vector4-add! (function vector4 vector4 vector4 none)) +(define-extern vector4-sub! (function vector4 vector4 vector4 none)) +(define-extern vector4-mul! (function vector4 vector4 vector4 none)) +(define-extern vector4-scale! (function vector4 vector4 float none)) +(define-extern vector4-madd! (function vector4 vector4 vector4 float none)) +(define-extern vector4-msub! (function vector4 vector4 vector4 float none)) +(define-extern vector4-array-add! (function (inline-array vector4) (inline-array vector4) (inline-array vector4) int none)) +(define-extern vector4-array-sub! (function (inline-array vector4) (inline-array vector4) (inline-array vector4) int none)) +(define-extern vector4-array-mul! (function (inline-array vector4) (inline-array vector4) (inline-array vector4) int none)) +(define-extern vector4-array-scale! (function (inline-array vector4) (inline-array vector4) float int none)) +(define-extern vector4-array-madd! (function (inline-array vector4) (inline-array vector4) (inline-array vector4) float int none)) +(define-extern vector4-array-msub! (function (inline-array vector4) (inline-array vector4) (inline-array vector4) float int none)) +(define-extern vector4-array-lerp! (function (inline-array vector4) (inline-array vector4) (inline-array vector4) float int none)) +(define-extern spheres-overlap? (function sphere sphere symbol)) +(define-extern sphere<-vector! (function sphere vector sphere)) +(define-extern sphere<-vector+r! (function sphere vector float sphere)) +(define-extern rand-vu-sphere-point! (function vector float vector)) +(define-extern vector-vector-angle-safe (function vector vector float)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; file-io ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| +(defenum file-kind + :bitfield #f + (level-bt 0) ;; aka bsp-header. + (art-group 1) + (tpage 2) + (dir-tpage 3) + (level-vs 4) + (tx 5) + (vis 6) + (map 7) + ) + (deftype file-stream (basic) - () + ((flags uint32 :offset-assert 4) + (mode symbol :offset-assert 8) + (name string :offset-assert 12) + (file uint32 :offset-assert 16) + ) + (:methods + (new (symbol type string symbol) _type_) + ) :method-count-assert 9 :size-assert #x14 :flag-assert #x900000014 - ;; Failed to read fields. ) -|# -#| (deftype file-info (basic) - ((file-type symbol :offset-assert 4) ;; guessed by decompiler + ((file-type (pointer string) :offset-assert 4) ;; guessed by decompiler (file-name basic :offset-assert 8) (major-version uint32 :offset-assert 12) (minor-version uint32 :offset-assert 16) @@ -3350,46 +4411,73 @@ :size-assert #x20 :flag-assert #x900000020 ) -|# -;; (define-extern file-stream-read-string object) ;; (function file-stream string string) -;; (define-extern *file-temp-string* object) ;; string -;; (define-extern make-file-name object) ;; (function file-kind string int symbol string) -;; (define-extern make-vfile-name object) ;; (function file-kind string string) -;; (define-extern file-info-correct-version? object) ;; (function file-info file-kind int symbol) +(define-extern file-stream-read-string (function file-stream string string)) +(define-extern *file-temp-string* string) +(define-extern make-file-name (function file-kind string int symbol string)) +(define-extern make-vfile-name (function file-kind string string)) +(define-extern file-info-correct-version? (function file-info file-kind int symbol)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; loader-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| +(declare-type art-group basic) +(define-extern art-group type) + +(deftype load-dir (basic) + ;; copied from jak1. + ((lev level :offset-assert 4) + (string-array (array string) :offset-assert 8) ;; these are the names + (data-array (array basic) :score -50 :offset-assert 12) ;; this is the file data. + ) + :method-count-assert 11 + :size-assert #x10 + :flag-assert #xb00000010 + ;; Failed to read fields. + (:methods + (new (symbol type int level) _type_ 0) + (dummy-9 () none 9) ;; (load-to-heap-by-name (_type_ string symbol kheap int) art-group 9) + (dummy-10 () none 10) ;; (set-loaded-art (_type_ art-group) art-group 10) + ) + ) + +(deftype load-dir-art-group (load-dir) + ((art-group-array (array art-group) :offset 12) + ) + :flag-assert #xb00000010 + (:methods + (new (symbol type int level) _type_ 0) + ) + ) + (deftype external-art-buffer (basic) ((index int32 :offset-assert 4) (other external-art-buffer :offset-assert 8) ;; guessed by decompiler (status symbol :offset-assert 12) ;; guessed by decompiler (locked? symbol :offset-assert 16) ;; guessed by decompiler - (login? basic :offset-assert 20) + (login? symbol :offset-assert 20) (frame-lock symbol :offset-assert 24) ;; guessed by decompiler - (init-heap basic :offset-assert 28) + (init-heap function :offset-assert 28) (heap kheap :inline :offset-assert 32) (pending-load-file string :offset-assert 48) ;; guessed by decompiler (pending-load-file-part int32 :offset-assert 52) - (pending-load-file-owner uint64 :offset-assert 56) ;; handle + (pending-load-file-owner handle :offset-assert 56) (pending-load-file-priority float :offset-assert 64) (load-file string :offset-assert 68) ;; guessed by decompiler (load-file-part int32 :offset-assert 72) - (load-file-owner uint64 :offset-assert 80) ;; handle + (load-file-owner handle :offset-assert 80) (load-file-priority float :offset-assert 88) (buf pointer :offset-assert 92) ;; guessed by decompiler (len int32 :offset-assert 96) (art-group art-group :offset-assert 100) ;; guessed by decompiler - (art-data uint32 :offset-assert 100) + (art-data uint32 :offset 100) ) :method-count-assert 16 :size-assert #x68 :flag-assert #x1000000068 (:methods - ;; (new (symbol type int) _type_ 0) + (new (symbol type int function symbol) _type_ 0) (dummy-9 () none 9) ;; (set-pending-file (_type_ string int handle float) int 9) (dummy-10 () none 10) ;; (update (_type_) int 10) (dummy-11 () none 11) ;; (inactive? (_type_) symbol 11) @@ -3399,14 +4487,12 @@ (dummy-15 () none 15) ;; (unlock! (_type_) symbol 15) ) ) -|# -#| (deftype spool-anim (basic) - ((name string :offset-assert 16) ;; guessed by decompiler + ((name string :offset 16) ;; guessed by decompiler (anim-name basic :offset-assert 20) (parts int32 :offset-assert 24) - (hint-id int32 :offset-assert 24) + (hint-id int32 :offset 24) (priority float :offset-assert 28) (owner uint64 :offset-assert 32) ;; handle (command-list pair :offset-assert 40) ;; guessed by decompiler @@ -3415,18 +4501,16 @@ :size-assert #x2c :flag-assert #x90000002c ) -|# -#| (deftype external-art-control (basic) ((buffer external-art-buffer 2 :offset-assert 4) ;; guessed by decompiler - (rec spool-anim 3 :offset-assert 20) ;; guessed by decompiler - (spool-lock uint64 :offset-assert 160) ;; handle - (reserve-buffer external-art-buffer :offset-assert 168) ;; guessed by decompiler - (reserve-buffer-count int16 :offset-assert 172) ;; int32 + (rec spool-anim 3 :inline :offset-assert 16) ;; guessed by decompiler + (spool-lock handle :offset-assert 160) + (reserve-buffer external-art-buffer :offset-assert 168) + (reserve-buffer-count int16 :offset-assert 172) (dma-reserve-buffer-count int16 :offset-assert 174) - (active-stream string :offset-assert 176) ;; guessed by decompiler - (queue-stream basic :offset-assert 180) + (active-stream string :offset-assert 176) + (queue-stream (array spool-anim) :offset-assert 180) (frame-mask uint32 :offset-assert 184) (dma-reserve-heap kheap :inline :offset-assert 192) ) @@ -3444,73 +4528,73 @@ (dummy-15 () none 15) ;; (none-reserved? (_type_) symbol 15) ) ) -|# -#| + (deftype subtitle-range (basic) - () + ((start-frame float :offset-assert 4) + (end-frame float :offset-assert 8) + (message object 8 :offset-assert 12) + ) :method-count-assert 9 :size-assert #x2c :flag-assert #x90000002c ;; Failed to read fields. ) -|# -#| + (deftype subtitle-image (basic) ((width uint16 :offset-assert 4) (height uint16 :offset-assert 6) - (palette UNKNOWN 16 :offset-assert 16) - (data UNKNOWN :dynamic :offset-assert 80) + (palette rgba 16 :offset 16) + (data uint8 :dynamic :offset-assert 80) ) :method-count-assert 9 :size-assert #x50 :flag-assert #x900000050 ) -|# ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; texture-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| +(declare-type texture-page basic) + (deftype texture-id (uint32) - () + ((index uint16 :offset 8 :size 12) + (page uint16 :offset 20 :size 12) + ) :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 - ;; Failed to read some fields. ) -|# -#| (deftype texture-pool-segment (structure) ((dest uint32 :offset-assert 0) (size uint32 :offset-assert 4) ) + :allow-misaligned + :pack-me :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype texture-pool (basic) - ((top int32 :offset-assert 4) - (cur int32 :offset-assert 8) - (allocate-func (function texture-pool texture-page kheap int texture-page) :offset-assert 12) ;; guessed by decompiler - (font-palette int32 :offset-assert 16) - (segment texture-pool-segment 4 :offset-assert 20) ;; guessed by decompiler - (segment-near texture-pool-segment :inline :offset-assert 20) - (segment-common texture-pool-segment :inline :offset-assert 28) - (common-page texture-page 32 :offset-assert 52) ;; guessed by decompiler - (common-page-mask int32 :offset-assert 180) - (update-sprites-flag basic :offset-assert 184) - (update-flag basic :offset-assert 188) - (texture-enable-user uint64 :offset-assert 192) - (texture-enable-user-menu uint64 :offset-assert 200) - (ids uint32 128 :offset-assert 208) ;; guessed by decompiler + ((top int32 :offset-assert 4) + (cur int32 :offset-assert 8) + (allocate-func (function texture-pool texture-page kheap int texture-page) :offset-assert 12) ;; guessed by decompiler + (font-palette int32 :offset-assert 16) + (segment texture-pool-segment 4 :inline :offset-assert 20) ;; guessed by decompiler + (segment-near texture-pool-segment :inline :offset 20) + (segment-common texture-pool-segment :inline :offset 28) + (common-page texture-page 32 :offset-assert 52) ;; guessed by decompiler + (common-page-mask int32 :offset-assert 180) + (update-sprites-flag basic :offset-assert 184) + (update-flag basic :offset-assert 188) + (texture-enable-user uint64 :offset-assert 192) + (texture-enable-user-menu uint64 :offset-assert 200) + (ids uint32 128 :offset-assert 208) ;; guessed by decompiler ) :method-count-assert 26 :size-assert #x2d0 @@ -3536,89 +4620,79 @@ (dummy-25 () none 25) ) ) -|# -#| (deftype texture-mask (structure) ((mask vector4w :inline :offset-assert 0) - (dist float :offset-assert 12) - (long UNKNOWN 2 :offset-assert 0) - (quad uint128 :offset-assert 0) + (dist float :offset 12) + (long uint64 2 :offset 0) + (quad uint128 :offset 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype texture-masks (structure) - ((data UNKNOWN 3 :offset-assert 0) + ((data texture-mask 3 :inline :offset-assert 0) ) :method-count-assert 9 :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype texture-masks-array (inline-array-class) - ((data UNKNOWN :dynamic :offset-assert 16) + ((data texture-masks :inline :dynamic :offset-assert 16) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype texture (basic) ((w int16 :offset-assert 4) (h int16 :offset-assert 6) (num-mips uint8 :offset-assert 8) (tex1-control uint8 :offset-assert 9) - (psm uint8 :offset-assert 10) ;; gs-psm + (psm gs-psm :offset-assert 10) (mip-shift uint8 :offset-assert 11) (clutpsm uint16 :offset-assert 12) - (dest uint16 7 :offset-assert 14) ;; guessed by decompiler + (dest uint16 7 :offset-assert 14) (clutdest uint16 :offset-assert 28) - (width uint8 7 :offset-assert 30) ;; guessed by decompiler - (name string :offset-assert 40) ;; guessed by decompiler + (width uint8 7 :offset-assert 30) + (name string :offset-assert 40) (size uint32 :offset-assert 44) (uv-dist float :offset-assert 48) - (pad UNKNOWN 3 :offset-assert 52) - (masks texture-masks :inline :offset-assert 64) ;; uint32 3 + (pad uint32 3 :offset-assert 52) + (masks texture-masks :inline :offset-assert 64) ) :method-count-assert 9 :size-assert #x70 :flag-assert #x900000070 ) -|# -#| (deftype texture-page-segment (structure) ((block-data pointer :offset-assert 0) ;; guessed by decompiler (size uint32 :offset-assert 4) (dest uint32 :offset-assert 8) ) + :allow-misaligned + :pack-me :method-count-assert 9 :size-assert #xc :flag-assert #x90000000c ) -|# -#| (deftype texture-page (basic) - ((info file-info :offset-assert 4) ;; guessed by decompiler - (name basic :offset-assert 8) - (id uint32 :offset-assert 12) - (length int32 :offset-assert 16) - (mip0-size uint32 :offset-assert 20) - (size uint32 :offset-assert 24) - (segment texture-page-segment 3 :offset-assert 28) ;; guessed by decompiler - (dram-size uint32 :offset-assert 64) - (pad uint32 15 :offset-assert 68) ;; guessed by decompiler - (data texture :dynamic :offset-assert 128) ;; guessed by decompiler + ((info file-info :offset-assert 4) + (name basic :offset-assert 8) + (id uint32 :offset-assert 12) + (length int32 :offset-assert 16) + (mip0-size uint32 :offset-assert 20) + (size uint32 :offset-assert 24) + (segment texture-page-segment 3 :inline :offset-assert 28) + (dram-size uint32 :offset-assert 64) + (pad uint32 15 :offset-assert 68) + (data texture :dynamic :offset-assert 128) ) :method-count-assert 14 :size-assert #x80 @@ -3631,9 +4705,14 @@ (dummy-13 () none 13) ;; (add-to-dma-buffer (_type_ dma-buffer int) int 13) ) ) -|# -#| +(deftype shader-ptr (uint32) + ((shader uint32 :offset 8 :size 24)) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + (deftype texture-link (structure) ((next shader-ptr :offset-assert 0) ;; guessed by decompiler ) @@ -3641,72 +4720,72 @@ :size-assert #x4 :flag-assert #x900000004 ) -|# -#| (deftype texture-page-dir-entry (structure) ((length int16 :offset-assert 0) (status uint16 :offset-assert 2) - (page texture-page :offset-assert 4) ;; guessed by decompiler - (link texture-link :offset-assert 8) ;; guessed by decompiler + (page texture-page :offset-assert 4) + (link texture-link :offset-assert 8) ) + :pack-me + :allow-misaligned :method-count-assert 9 :size-assert #xc :flag-assert #x90000000c ) -|# -#| (deftype texture-relocate-later (basic) - ((memcpy symbol :offset-assert 4) ;; guessed by decompiler + ((memcpy symbol :offset-assert 4) (dest uint32 :offset-assert 8) (source uint32 :offset-assert 12) (move uint32 :offset-assert 16) (entry texture-page-dir-entry :offset-assert 20) - (page texture-page :offset-assert 24) ;; guessed by decompiler + (page texture-page :offset-assert 24) ) :method-count-assert 9 :size-assert #x1c :flag-assert #x90000001c ) -|# -#| +(defenum link-test-flags + :type uint32 + :bitfield #t + ; (needs-log-in 8) + ; (bit-9 9) + ) + + (deftype adgif-shader (structure) - ((quad qword 5 :offset-assert 0) ;; guessed by decompiler - (prims gs-reg64 10 :offset-assert 0) ;; guessed by decompiler - (reg-0 uint8 :offset-assert 8) - (reg-1 uint8 :offset-assert 24) - (reg-2 uint8 :offset-assert 40) - (reg-3 uint8 :offset-assert 56) - (reg-4 uint8 :offset-assert 72) - (tex0 uint64 :offset-assert 0) ;; gs-tex0 - (tex1 uint64 :offset-assert 16) ;; gs-tex1 - (miptbp1 uint64 :offset-assert 32) ;; gs-miptbp - (clamp uint64 :offset-assert 48) ;; gs-clamp - (clamp-reg uint64 :offset-assert 56) ;; gs-reg64 - (alpha uint64 :offset-assert 64) ;; gs-alpha - (link-test link-test-flags :offset-assert 8) ;; guessed by decompiler - (texture-id texture-id :offset-assert 24) ;; guessed by decompiler - (next shader-ptr :offset-assert 40) ;; guessed by decompiler + ((quad qword 5 :offset-assert 0) + (prims gs-reg64 10 :offset 0) + (reg-0 uint8 :offset 8) + (reg-1 uint8 :offset 24) + (reg-2 uint8 :offset 40) + (reg-3 uint8 :offset 56) + (reg-4 uint8 :offset 72) + (tex0 gs-tex0 :offset 0) + (tex1 gs-tex1 :offset 16) + (miptbp1 gs-miptbp :offset 32) + (clamp gs-clamp :offset 48) + (clamp-reg gs-reg64 :offset 56) + (alpha gs-alpha :offset 64) + (link-test link-test-flags :offset 8) + (texture-id texture-id :offset 24) + (next shader-ptr :offset 40) ) :method-count-assert 9 :size-assert #x50 :flag-assert #x900000050 ) -|# -#| (deftype adgif-shader-array (inline-array-class) - ((data adgif-shader :dynamic :offset-assert 16) ;; guessed by decompiler + ((data adgif-shader :inline :dynamic :offset-assert 16) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype texture-base (structure) ((vram-page uint32 :offset-assert 0) (vram-block uint32 :offset-assert 4) @@ -3716,76 +4795,83 @@ :size-assert #xc :flag-assert #x90000000c ) -|# -#| (deftype texture-page-translate-item (structure) - ((bucket int32 :offset-assert 0) - (level-index uint32 :offset-assert 4) - (level-texture-page uint32 :offset-assert 8) - (texture-user uint32 :offset-assert 12) + ((bucket bucket-id :offset-assert 0) + (level-index uint32 :offset-assert 4) + (level-texture-page uint32 :offset-assert 8) + (texture-user uint32 :offset-assert 12) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -;; (define-extern *texture-masks* object) -;; (define-extern *texture-masks-array* object) -;; (define-extern texture-mip->segment object) ;; (function int int int) -;; (define-extern *texture-relocate-later* object) ;; texture-relocate-later -;; (define-extern *texture-page-dir* object) ;; texture-page-dir -;; (define-extern ct32-24-block-table object) ;; (array int32) -;; (define-extern mz32-24-block-table object) ;; (array int32) -;; (define-extern ct16-block-table object) ;; (array int32) -;; (define-extern ct16s-block-table object) ;; (array int32) -;; (define-extern mz16-block-table object) ;; (array int32) -;; (define-extern mz16s-block-table object) ;; (array int32) -;; (define-extern mt8-block-table object) ;; (array int32) -;; (define-extern mt4-block-table object) ;; (array int32) -;; (define-extern *texture-page-translate* object) -;; (define-extern *eyes-texture-base* object) -;; (define-extern *skull-gem-texture-base* object) -;; (define-extern *ocean-texture-base* object) -;; (define-extern *ocean-envmap-texture-base* object) -;; (define-extern *grey-scale-base* object) -;; (define-extern *map-texture-base* object) +(deftype texture-page-dir (basic) + ((length int32) + (entries texture-page-dir-entry 1 :inline) + ) + (:methods + (relocate (_type_ kheap (pointer uint8)) none :replace 7) + (unlink-textures-in-heap! (_type_ kheap) int 9) + ) + :flag-assert #xa00000014 + ) + +(define-extern *texture-masks* texture-masks) +(define-extern *texture-masks-array* texture-masks-array) +(define-extern texture-mip->segment (function int int int)) +(define-extern *texture-relocate-later* texture-relocate-later) +(define-extern *texture-page-dir* texture-page-dir) +(define-extern ct32-24-block-table (array int32)) +(define-extern mz32-24-block-table (array int32)) +(define-extern ct16-block-table (array int32)) +(define-extern ct16s-block-table (array int32)) +(define-extern mz16-block-table (array int32)) +(define-extern mz16s-block-table (array int32)) +(define-extern mt8-block-table (array int32)) +(define-extern mt4-block-table (array int32)) +(define-extern *texture-page-translate* (array texture-page-translate-item)) +(define-extern *eyes-texture-base* texture-base) +(define-extern *skull-gem-texture-base* texture-base) +(define-extern *ocean-texture-base* texture-base) +(define-extern *ocean-envmap-texture-base* texture-base) +(define-extern *grey-scale-base* texture-base) +(define-extern *map-texture-base* texture-base) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; texture-anim-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype texture-anim-layer (structure) - ((extra vector :inline :offset-assert 240) - (func basic :offset-assert 256) - (func-id basic :offset-assert 256) - (init-func basic :offset-assert 260) - (init-func-id basic :offset-assert 260) - (tex basic :offset-assert 264) - (start-time float :offset-assert 268) - (end-time float :offset-assert 272) - (tex-name basic :offset-assert 276) - (test uint64 :offset-assert 280) - (alpha uint64 :offset-assert 288) - (clamp uint64 :offset-assert 296) - (start-color vector :inline :offset-assert 80) - (start-scale vector2 :inline :offset-assert 96) - (start-offset vector2 :inline :offset-assert 104) - (start-st-scale vector2 :inline :offset-assert 112) - (start-st-offset vector2 :inline :offset-assert 120) - (start-qs vector :inline :offset-assert 128) - (start-rot deg :offset-assert 144) - (start-st-rot deg :offset-assert 148) - (end-color vector :inline :offset-assert 160) - (end-scale vector2 :inline :offset-assert 176) - (end-offset vector2 :inline :offset-assert 184) - (end-st-scale vector2 :inline :offset-assert 192) - (end-st-offset vector2 :inline :offset-assert 200) - (end-qs vector :inline :offset-assert 208) - (end-rot deg :offset-assert 224) - (end-st-rot deg :offset-assert 228) + ((extra vector :inline :offset 240) + (func basic :offset 256) + (func-id basic :offset 256) + (init-func basic :offset 260) + (init-func-id basic :offset 260) + (tex basic :offset 264) + (start-time float :offset 268) + (end-time float :offset 272) + (tex-name basic :offset 276) + (test uint64 :offset 280) + (alpha uint64 :offset 288) + (clamp uint64 :offset 296) + (start-color vector :inline :offset 80) + (start-scale vector2 :inline :offset 96) + (start-offset vector2 :inline :offset 104) + (start-st-scale vector2 :inline :offset 112) + (start-st-offset vector2 :inline :offset 120) + (start-qs vector :inline :offset 128) + (start-rot degrees :offset 144) + (start-st-rot degrees :offset 148) + (end-color vector :inline :offset 160) + (end-scale vector2 :inline :offset 176) + (end-offset vector2 :inline :offset 184) + (end-st-scale vector2 :inline :offset 192) + (end-st-offset vector2 :inline :offset 200) + (end-qs vector :inline :offset 208) + (end-rot degrees :offset 224) + (end-st-rot degrees :offset 228) ) :method-count-assert 11 :size-assert #x130 @@ -3795,15 +4881,13 @@ (dummy-10 () none 10) ) ) -|# -#| (deftype texture-anim (structure) ((num-layers uint32 :offset-assert 0) (func basic :offset-assert 4) - (func-id basic :offset-assert 4) + (func-id basic :offset 4) (init-func basic :offset-assert 8) - (init-func-id basic :offset-assert 8) + (init-func-id basic :offset 8) (tex basic :offset-assert 12) (tex-name basic :offset-assert 16) (extra vector :inline :offset-assert 32) @@ -3814,7 +4898,7 @@ (test uint64 :offset-assert 64) (alpha uint64 :offset-assert 72) (clamp uint64 :offset-assert 80) - (data UNKNOWN :dynamic :offset-assert 88) + (data uint8 :dynamic :offset-assert 88) ) :method-count-assert 11 :size-assert #x58 @@ -3824,15 +4908,9 @@ (dummy-10 () none 10) ) ) -|# -#| (deftype texture-anim-array (array) - ((type basic :offset-assert 0) - (length int32 :offset-assert 4) - (allocated-length int32 :offset-assert 8) - (content-type basic :offset-assert 12) - ) + () :method-count-assert 11 :size-assert #x10 :flag-assert #xb00000010 @@ -3841,9 +4919,7 @@ (dummy-10 () none 10) ) ) -|# -#| (deftype texture-anim-work (structure) ((erase-tmpl dma-gif-packet :inline :offset-assert 0) (draw-tmpl dma-gif-packet :inline :offset-assert 32) @@ -3855,161 +4931,139 @@ (corner2 vector :inline :offset-assert 192) (corner3 vector :inline :offset-assert 208) (const vector :inline :offset-assert 224) - (random UNKNOWN 8 :offset-assert 240) + (random vector 8 :inline :offset-assert 240) (random-index uint8 :offset-assert 368) ) :method-count-assert 9 :size-assert #x171 :flag-assert #x900000171 ) -|# -#| (deftype clut16x16 (structure) - ((clut UNKNOWN 256 :offset-assert 0) + ((clut rgba 256 :offset-assert 0) ) :method-count-assert 9 :size-assert #x400 :flag-assert #x900000400 ) -|# -#| (deftype noise8x8 (structure) - ((image UNKNOWN 64 :offset-assert 0) + ((image uint8 64 :offset-assert 0) ) :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 ) -|# -#| (deftype noise16x16 (structure) - ((image UNKNOWN 256 :offset-assert 0) + ((image uint8 256 :offset-assert 0) ) :method-count-assert 9 :size-assert #x100 :flag-assert #x900000100 ) -|# -#| (deftype noise32x32 (structure) - ((image UNKNOWN 1024 :offset-assert 0) + ((image uint8 1024 :offset-assert 0) ) :method-count-assert 9 :size-assert #x400 :flag-assert #x900000400 ) -|# -#| (deftype noise64x64 (structure) - ((image UNKNOWN 4096 :offset-assert 0) + ((image uint8 4096 :offset-assert 0) ) :method-count-assert 9 :size-assert #x1000 :flag-assert #x900001000 ) -|# -#| (deftype noise128x128 (structure) - ((image UNKNOWN 16384 :offset-assert 0) + ((image uint8 16384 :offset-assert 0) ) :method-count-assert 9 :size-assert #x4000 :flag-assert #x900004000 ) -|# -#| + (deftype fog8x256 (structure) - ((image UNKNOWN 256 :offset-assert 0) + ((image uint8 256 :offset-assert 0) ) :method-count-assert 9 :size-assert #x100 :flag-assert #x900000100 ) -|# -#| + (deftype fog-texture-work (structure) - ((corner UNKNOWN 4 :offset-assert 0) - (const vector :inline :offset-assert 64) - (min-corner vector :inline :offset-assert 80) - (max-corner vector :inline :offset-assert 96) - (fog-near float :offset-assert 112) - (fog-far float :offset-assert 116) - (fog-delta float :offset-assert 120) - (alpha-near float :offset-assert 124) - (alpha-far float :offset-assert 128) - (alpha-delta float :offset-assert 132) - (color uint32 :offset-assert 136) + ((corner vector 4 :inline :offset-assert 0) + (const vector :inline :offset-assert 64) + (min-corner vector :inline :offset-assert 80) + (max-corner vector :inline :offset-assert 96) + (fog-near float :offset-assert 112) + (fog-far float :offset-assert 116) + (fog-delta float :offset-assert 120) + (alpha-near float :offset-assert 124) + (alpha-far float :offset-assert 128) + (alpha-delta float :offset-assert 132) + (color uint32 :offset-assert 136) ) :method-count-assert 9 :size-assert #x8c :flag-assert #x90000008c ) -|# -;; (define-extern *clut-translate* object) +(define-extern *clut-translate* (pointer uint32)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; lights-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype vu-lights (structure) - ((direction vector 3 :offset-assert 0) ;; guessed by decompiler - (color vector 3 :offset-assert 48) ;; guessed by decompiler - (ambient vector :inline :offset-assert 96) + ((direction vector 3 :inline :offset-assert 0) + (color vector 3 :inline :offset-assert 48) + (ambient vector :inline :offset-assert 96) ) :method-count-assert 9 :size-assert #x70 :flag-assert #x900000070 ) -|# -#| (deftype light (structure) ((direction vector :inline :offset-assert 0) (color rgbaf :inline :offset-assert 16) (extra vector :inline :offset-assert 32) - (level float :offset-assert 32) - (luminance float :offset-assert 40) - (priority float :offset-assert 44) - (bytes UNKNOWN 4 :offset-assert 36) - (mask uint16 :offset-assert 36) - (palette-index int8 :offset-assert 39) + (level float :offset 32) + (luminance float :offset 40) + (priority float :offset 44) + (bytes uint8 4 :offset 36) + (mask uint16 :offset 36) + (palette-index int8 :offset 39) ) :method-count-assert 9 :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype light-sphere (structure) ((name basic :offset-assert 0) (bsphere vector :inline :offset-assert 16) (direction vector :inline :offset-assert 32) (color vector :inline :offset-assert 48) - (decay-start float :offset-assert 4) - (ambient-point-ratio float :offset-assert 8) - (brightness float :offset-assert 12) - (bytes UNKNOWN 4 :offset-assert 60) - (mask uint16 :offset-assert 60) - (palette-index int8 :offset-assert 63) + (decay-start float :offset 4) + (ambient-point-ratio float :offset 8) + (brightness float :offset 12) + (bytes uint8 4 :offset 60) + (mask uint16 :offset 60) + (palette-index int8 :offset 63) ) :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 ) -|# -#| (deftype light-hash-bucket (structure) ((index uint16 :offset-assert 0) (count uint16 :offset-assert 2) @@ -4018,14 +5072,12 @@ :size-assert #x4 :flag-assert #x900000004 ) -|# -#| (deftype light-hash (basic) ((num-lights uint16 :offset-assert 4) (num-indices uint16 :offset-assert 6) (num-buckets uint16 :offset-assert 8) - (bucket-step UNKNOWN 2 :offset-assert 10) + (bucket-step uint16 2 :offset-assert 10) (base-trans vector :inline :offset-assert 16) (axis-scale vector :inline :offset-assert 32) (dimension-array vector4w :inline :offset-assert 48) @@ -4037,9 +5089,7 @@ :size-assert #x4c :flag-assert #x90000004c ) -|# -#| (deftype light-hash-work (structure) ((ones vector4w :inline :offset-assert 0) ) @@ -4047,9 +5097,7 @@ :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype light-group (structure) ((dir0 light :inline :offset-assert 0) (dir1 light :inline :offset-assert 48) @@ -4060,62 +5108,52 @@ :size-assert #xc0 :flag-assert #x9000000c0 ) -|# -;; (define-extern *light-hash* object) +(define-extern *light-hash* light-hash-work) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; mood-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype mood-channel (structure) - ((data UNKNOWN 24 :offset-assert 0) - (vecs UNKNOWN 6 :offset-assert 0) + ((data float 24 :offset-assert 0) + (vecs vector4 6 :inline :offset 0) ) :method-count-assert 9 :size-assert #x60 :flag-assert #x900000060 ) -|# -#| (deftype mood-channel-group (structure) - ((data UNKNOWN 4 :offset-assert 0) + ((data mood-channel 4 :inline :offset-assert 0) ) :method-count-assert 9 :size-assert #x180 :flag-assert #x900000180 ) -|# -#| (deftype mood-fog (structure) ((fog-color vector :inline :offset-assert 0) (fog-dists vector :inline :offset-assert 16) - (fog-start meters :offset-assert 16) - (fog-end meters :offset-assert 20) - (fog-max float :offset-assert 24) - (fog-min float :offset-assert 28) + (fog-start meters :offset 16) + (fog-end meters :offset 20) + (fog-max float :offset 24) + (fog-min float :offset 28) (erase-color vector :inline :offset-assert 32) ) :method-count-assert 9 :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype mood-fog-table (structure) - ((data mood-fog 8 :offset-assert 0) ;; guessed by decompiler + ((data mood-fog 8 :inline :offset-assert 0) ) :method-count-assert 9 :size-assert #x180 :flag-assert #x900000180 ) -|# -#| (deftype mood-color (structure) ((lgt-color vector :inline :offset-assert 0) (amb-color vector :inline :offset-assert 16) @@ -4124,39 +5162,31 @@ :size-assert #x20 :flag-assert #x900000020 ) -|# -#| (deftype mood-direction-table (structure) - ((data UNKNOWN 4 :offset-assert 0) + ((data vector 4 :inline :offset-assert 0) ) :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 ) -|# -#| (deftype mood-color-table (structure) - ((data UNKNOWN 8 :offset-assert 0) + ((data mood-color 8 :inline :offset-assert 0) ) :method-count-assert 9 :size-assert #x100 :flag-assert #x900000100 ) -|# -#| (deftype mood-sky-table (structure) - ((data UNKNOWN 8 :offset-assert 0) + ((data vector 8 :inline :offset-assert 0) ) :method-count-assert 9 :size-assert #x80 :flag-assert #x900000080 ) -|# -#| (deftype mood-clouds (structure) ((cloud-min float :offset-assert 0) (cloud-max float :offset-assert 4) @@ -4165,58 +5195,51 @@ :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype mood-weather (structure) - ((data UNKNOWN 2 :offset-assert 0) - (cloud float :offset-assert 0) - (fog float :offset-assert 4) + ((data float 2 :offset-assert 0) + (cloud float :offset 0) + (fog float :offset 4) ) + :pack-me + :allow-misaligned :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype mood-iweather (structure) - ((data UNKNOWN 2 :offset-assert 0) - (cloud int32 :offset-assert 0) - (fog int32 :offset-assert 4) + ((data int32 2 :offset-assert 0) + (cloud int32 :offset 0) + (fog int32 :offset 4) ) + :allow-misaligned :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype mood-range (structure) - ((data UNKNOWN 4 :offset-assert 0) - (min-cloud float :offset-assert 0) - (max-cloud float :offset-assert 4) - (min-fog float :offset-assert 8) - (max-fog float :offset-assert 12) - (quad uint128 :offset-assert 0) + ((data float 4 :offset-assert 0) + (min-cloud float :offset 0) + (max-cloud float :offset 4) + (min-fog float :offset 8) + (max-fog float :offset 12) + (quad uint128 :offset 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype mood-filters-table (structure) - ((data UNKNOWN 8 :offset-assert 0) + ((data vector 8 :inline :offset-assert 0) ) :method-count-assert 9 :size-assert #x80 :flag-assert #x900000080 ) -|# -#| (deftype mood-table (basic) ((mood-fog-table mood-fog-table :offset-assert 4) (mood-color-table mood-color-table :offset-assert 8) @@ -4229,9 +5252,7 @@ :size-assert #x1c :flag-assert #x90000001c ) -|# -#| (deftype mood-context-core (structure) ((current-fog mood-fog :inline :offset-assert 0) (current-sky-color vector :inline :offset-assert 48) @@ -4243,59 +5264,49 @@ :size-assert #x70 :flag-assert #x900000070 ) -|# -#| (deftype mood-context-core2 (mood-context-core) - ((light-group UNKNOWN 8 :offset-assert 112) + ((light-group light-group 8 :inline :offset-assert 112) ) :method-count-assert 9 :size-assert #x670 :flag-assert #x900000670 ) -|# -#| (deftype mood-context-core3 (mood-context-core2) - ((times UNKNOWN 8 :offset-assert 1648) + ((times vector 8 :inline :offset-assert 1648) ) :method-count-assert 9 :size-assert #x6f0 :flag-assert #x9000006f0 ) -|# -#| (deftype mood-context (mood-context-core3) - ((itimes vector4w 4 :offset-assert 1776) ;; guessed by decompiler - (state uint8 32 :offset-assert 1840) ;; guessed by decompiler + ((itimes vector4w 4 :inline :offset-assert 1776) + (state uint32 32 :offset-assert 1840) ) :method-count-assert 9 :size-assert #x7b0 :flag-assert #x9000007b0 ) -|# -#| (deftype mood-control-work (structure) ((weather mood-weather :inline :offset-assert 0) (iweather mood-iweather :inline :offset-assert 8) (interp mood-weather :inline :offset-assert 16) - (index UNKNOWN 4 :offset-assert 24) + (index int32 4 :offset-assert 24) (color-interp float :offset-assert 40) - (color-index UNKNOWN 2 :offset-assert 44) + (color-index int32 2 :offset-assert 44) (channel-interp float :offset-assert 52) - (channel-index UNKNOWN 2 :offset-assert 56) + (channel-index int32 2 :offset-assert 56) (cloud-interp float :offset-assert 64) - (cloud-index UNKNOWN 2 :offset-assert 68) + (cloud-index int32 2 :offset-assert 68) ) :method-count-assert 9 :size-assert #x4c :flag-assert #x90000004c ) -|# -#| (deftype mood-control (mood-table) ((mood-clouds mood-clouds :offset-assert 28) (current-interp mood-weather :inline :offset-assert 32) @@ -4319,10 +5330,10 @@ (lightning-count2 uint32 :offset-assert 152) (rain-id uint32 :offset-assert 156) (sound-pitch float :offset-assert 160) - (fogs UNKNOWN 9 :offset-assert 164) - (colors UNKNOWN 3 :offset-assert 200) - (channels UNKNOWN 3 :offset-assert 212) - (clouds UNKNOWN 9 :offset-assert 224) + (fogs mood-fog 9 :offset-assert 164) ;; these 4 are guesses + (colors mood-color 3 :offset-assert 200) + (channels mood-channel 3 :offset-assert 212) + (clouds mood-clouds 9 :offset-assert 224) ) :method-count-assert 19 :size-assert #x104 @@ -4340,34 +5351,167 @@ (dummy-18 () none 18) ) ) -|# ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; level-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| +(declare-type bsp-header basic) + +(defenum vis-info-flag + :type uint32 + :bitfield #t + (dummy0 0) + (dummy1 1) + (dummy2 2) + (dummy3 3) + (dummy4 4) + (dummy5 5) + (dummy6 6) + (dummy7 7) + (dummy8 8) + (dummy9 9) + (dummy10 10) + (dummy11 11) + (dummy12 12) + (dummy13 13) + (dummy14 14) + (dummy15 15) + (dummy16 16) + (dummy17 17) + (dummy18 18) + (dummy19 19) + (dummy20 20) + (dummy21 21) + (dummy22 22) + (dummy23 23) + (dummy24 24) + (dummy25 25) + (dummy26 26) + (dummy27 27) + (dummy28 28) + (in-iop 29) + (loading 30) + (vis-valid 31) + ) + (deftype level-vis-info (basic) - () + ((level level :offset-assert 4) + (from-level level :offset-assert 8) + (from-bsp bsp-header :offset-assert 12) + (flags vis-info-flag :offset-assert 16) + (length uint32 :offset-assert 20) + (allocated-length uint32 :offset-assert 24) + (dictionary-length uint32 :offset-assert 28) + (dictionary uint32 :offset-assert 32) + (string-block uint32 :offset-assert 36) + (ramdisk uint32 :offset-assert 40) + (vis-bits uint32 :offset-assert 44) + (current-vis-string uint32 :offset-assert 48) + (vis-string uint32 :dynamic :offset-assert 52) + ) :method-count-assert 9 :size-assert #x34 :flag-assert #x900000034 - ;; Failed to read fields. ) -|# -#| + +(defenum task-mask + :type uint32 + :bitfield #t + (task0 0) ;; 0x1 + (task1 1) ;; 0x2 + (task2 2) ;; 0x4 + (task3 3) ;; 0x8 + (task4 4) ;; 0x10 + (task5 5) ;; 0x20 + (task6 6) ;; 0x40 + (task7 7) ;; 0x80 + (done 8) ;; 0x100 + (dummy0 9) ;; 0x200 + (dummy1 10) ;; 0x400 + (dummy2 11) ;; 0x800 + (special 12) ;; 0x1000 + (primary0 13) ;; 0x2000 + (ctywide 14) ;; 0x4000 + (never 15) ;; 0x8000 + (movie0 16) ;; 0x10000 + (movie1 17) ;; 0x20000 + (movie2 18) ;; 0x40000 + ) + (deftype level-load-info (basic) - () + ((name-list string 6 :offset-assert 4) + (index int16 :offset-assert 28) + (task-level uint8 :offset-assert 30) + (name string :offset 4) + (visname string :offset 8) + (nickname string :offset 12) + (dbname string :offset 16) + (taskname string :offset 20) + (packages pair :offset-assert 32) ;; guess on type + (memory-mode uint32 :offset-assert 36) + (music-bank basic :offset-assert 40) + (ambient-sounds basic :offset-assert 44) + (sound-reverb float :offset-assert 48) + (mood-func basic :offset-assert 52) + (mood-init basic :offset-assert 56) + (ocean basic :offset-assert 60) + (sky basic :offset-assert 64) + (use-camera-other basic :offset-assert 68) + (part-engine-max int32 :offset-assert 72) + (city-map-bits uint64 :offset-assert 80) + (continues basic :offset-assert 88) + (tasks basic :offset-assert 92) + (priority int32 :offset-assert 96) + (load-commands basic :offset-assert 100) + (alt-load-commands basic :offset-assert 104) + (bsp-mask uint64 :offset-assert 112) + (buzzer int32 :offset-assert 120) + (buttom-height meters :offset-assert 124) + (run-packages basic :offset-assert 128) + (prev-level basic :offset-assert 132) + (next-level basic :offset-assert 136) + (wait-for-load symbol :offset-assert 140) + (login-func basic :offset-assert 144) + (activate-func basic :offset-assert 148) + (deactivate-func basic :offset-assert 152) + (kill-func basic :offset-assert 156) + (borrow-size uint16 2 :offset-assert 160) + (borrow-level symbol 2 :offset-assert 164) + (borrow-display? basic 2 :offset-assert 172) + (base-task-mask task-mask :offset-assert 180) + (texture-anim basic 10 :offset-assert 184) + (texture-anim-tfrag basic :offset 184) + (texture-anim-pris basic :offset 188) + (texture-anim-shrub basic :offset 192) + (texture-anim-alpha basic :offset 196) + (texture-anim-water basic :offset 200) + (texture-anim-twarp basic :offset 204) + (texture-anim-pris2 basic :offset 208) + (texture-anim-sprite basic :offset 212) + (texture-anim-map basic :offset 216) + (texture-anim-sky basic :offset 220) + (draw-priority float :offset-assert 224) + (level-flags uint32 :offset-assert 228) + (fog-height float :offset-assert 232) + (bigmap-id uint32 :offset-assert 236) + (ocean-near-translucent? symbol :offset-assert 240) + (ocean-far? symbol :offset-assert 244) + (mood-range mood-range :inline :offset-assert 256) + (max-rain float :offset-assert 272) + (fog-mult float :offset-assert 276) + (ocean-alpha float :offset-assert 280) + (extra-sound-bank basic :offset-assert 284) + ) :method-count-assert 9 :size-assert #x120 :flag-assert #x900000120 ;; Failed to read fields. ) -|# -#| +(declare-type drawable basic) (deftype login-state (basic) ((state int32 :offset-assert 4) (pos uint32 :offset-assert 8) @@ -4378,11 +5522,83 @@ :size-assert #x50 :flag-assert #x900000050 ) -|# -#| (deftype level (basic) - () + ((name symbol :offset-assert 4) + (load-name basic :offset-assert 8) + (nickname basic :offset-assert 12) + (index int32 :offset-assert 16) + (status symbol :offset-assert 20) + (borrow-level basic 2 :offset-assert 24) + (borrow-from-level basic :offset-assert 32) + (heap kheap :inline :offset-assert 48) + (borrow-heap kheap 2 :inline :offset-assert 64) + (bsp bsp-header :offset-assert 96) + (art-group basic :offset-assert 100) + (info basic :offset-assert 104) + (texture-page texture-page 18 :offset-assert 108) + (loaded-texture-page texture-page 16 :offset-assert 180) + (loaded-texture-page-count int32 :offset-assert 244) + (entity basic :offset-assert 248) + (closest-object float :offset-assert 252) + ;; ???? + (upload-size int32 18 :offset 324) + (inside-boxes symbol :offset-assert 396) + (display? symbol :offset-assert 400) + (render? symbol :offset-assert 404) + (meta-inside? symbol :offset-assert 408) + (force-inside? symbol :offset-assert 412) + (mood-context mood-context :inline :offset-assert 416) + (mood-func basic :offset-assert 2384) + (mood-init basic :offset-assert 2388) + (vis-bits pointer :offset-assert 2392) + (all-visible? symbol :offset-assert 2396) + (force-all-visible? symbol :offset-assert 2400) + (linking basic :offset-assert 2404) + (vis-info level-vis-info 8 :offset-assert 2408) + (vis-self-index int32 :offset-assert 2440) + (vis-adj-index int32 :offset-assert 2444) + (vis-buffer uint8 2048 :offset-assert 2448) + (mem-usage-block basic :offset-assert 4496) + (mem-usage int32 :offset-assert 4500) + (code-memory-start pointer :offset-assert 4504) + (code-memory-end pointer :offset-assert 4508) + (load-start-time time-frame :offset-assert 4512) + (load-stop-time time-frame :offset-assert 4520) + (load-buffer basic 2 :offset-assert 4528) + (load-buffer-size uint32 :offset-assert 4536) + (load-buffer-last uint32 :offset-assert 4540) + (load-buffer-mode uint32 :offset-assert 4544) + (display-start-time time-frame :offset-assert 4552) + (memory-mask uint32 :offset-assert 4560) + (task-mask task-mask :offset-assert 4564) + (tfrag-gs-test uint64 :offset-assert 4568) + (texture-dirty-masks texture-mask 10 :inline :offset-assert 4576) + (texture-mask texture-mask 18 :inline :offset-assert 4736) + (sky-mask texture-mask :inline :offset-assert 5024) + (tfrag-masks basic :offset-assert 5040) + (tfrag-dists pointer :offset-assert 5044) + (shrub-masks basic :offset-assert 5048) + (shrub-dists pointer :offset-assert 5052) + (alpha-masks basic :offset-assert 5056) + (alpha-dists pointer :offset-assert 5060) + (water-masks basic :offset-assert 5064) + (water-dists pointer :offset-assert 5068) + (tfrag-last-calls int32 6 :offset-assert 5072) + (texture-anim-array texture-anim-array 10 :offset-assert 5096) + (light-hash basic :offset-assert 5136) + (draw-priority float :offset-assert 5140) + (draw-index int32 :offset-assert 5144) + (part-engine basic :offset-assert 5148) + (user-object basic 4 :offset-assert 5152) + (loaded-text-info-count int32 :offset-assert 5168) + (loaded-text-info object 8 :offset-assert 5172) + (level-type basic :offset-assert 5204) + (load-order int64 :offset-assert 5208) + + ;; ?? + (pad int8 12) + ) :method-count-assert 30 :size-assert #x146c :flag-assert #x1e0000146c @@ -4411,11 +5627,47 @@ (dummy-29 () none 29) ) ) -|# -#| +(declare-type entity-links structure) + (deftype level-group (basic) - () + ((length int32 :offset-assert 4) + ;; not in inspect, copied from jak1 + (log-in-level-bsp bsp-header :offset-assert 8) + (loading-level level :offset-assert 12) + ;; + (entity-link entity-links :offset 16) + (border? symbol :offset-assert 20) + (vis? symbol :offset-assert 24) + (want-level basic :offset-assert 28) + (receiving-level basic :offset-assert 32) + (load-commands pair :offset-assert 36) + (play? symbol :offset-assert 40) + (target-pos vector 2 :inline :offset-assert 48) + (camera-pos vector 2 :inline :offset-assert 80) + (heap kheap :inline :offset-assert 112) + (sound-bank basic 4 :offset-assert 128) + (disk-load-timing? symbol :offset-assert 144) + (load-level basic :offset-assert 148) + (load-size uint32 :offset-assert 152) + (load-time float :offset-assert 156) + (load-login-time float :offset-assert 160) + (draw-level-count int32 :offset-assert 164) + (draw-level basic 7 :offset-assert 168) + (draw-index-map uint8 7 :offset-assert 196) + (load-order uint64 :offset-assert 208) + ;; ? + (pad uint8 30) + (level level 7 :inline :offset-assert 256) + (level0 level :inline :offset 256) + (level1 level :inline :offset 5488) + (level2 level :inline :offset 10720) + (level3 level :inline :offset 15952) + (level4 level :inline :offset 21184) + (level5 level :inline :offset 26416) + (default-level level :inline :offset 31648) + (pad2 uint8 4) + ) :method-count-assert 31 :size-assert #x9014 :flag-assert #x1f00009014 @@ -4445,38 +5697,34 @@ (dummy-30 () none 30) ) ) -|# -;; (define-extern *level* object) ;; level-group -;; (define-extern *draw-index* object) -;; (define-extern *level-index* object) +(define-extern *level* level-group) +(define-extern *draw-index* int) +(define-extern *level-index* int) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; capture-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype gs-store-image-packet (structure) - ((vifcode vif-tag 4 :offset-assert 0) ;; guessed by decompiler - (giftag uint128 :offset-assert 16) ;; gif-tag - (bitbltbuf uint64 :offset-assert 32) ;; gs-bitbltbuf - (bitbltbuf-addr uint64 :offset-assert 40) ;; gs-reg64 - (trxpos uint64 :offset-assert 48) ;; gs-trxpos - (trxpos-addr uint64 :offset-assert 56) ;; gs-reg64 - (trxreg uint64 :offset-assert 64) ;; gs-trxreg - (trxreg-addr uint64 :offset-assert 72) ;; gs-reg64 - (finish uint64 :offset-assert 80) ;; int64 - (finish-addr uint64 :offset-assert 88) ;; gs-reg64 - (trxdir uint64 :offset-assert 96) ;; gs-trxdir - (trxdir-addr uint64 :offset-assert 104) ;; gs-reg64 + ((vifcode vif-tag 4 :offset-assert 0) + (giftag gif-tag :offset-assert 16) + (bitbltbuf gs-bitbltbuf :offset-assert 32) + (bitbltbuf-addr gs-reg64 :offset-assert 40) + (trxpos gs-trxpos :offset-assert 48) + (trxpos-addr gs-reg64 :offset-assert 56) + (trxreg gs-trxreg :offset-assert 64) + (trxreg-addr gs-reg64 :offset-assert 72) + (finish int64 :offset-assert 80) + (finish-addr gs-reg64 :offset-assert 88) + (trxdir gs-trxdir :offset-assert 96) + (trxdir-addr gs-reg64 :offset-assert 104) ) :method-count-assert 9 :size-assert #x70 :flag-assert #x900000070 ) -|# -#| (deftype screen-shot-work (structure) ((count int16 :offset-assert 0) (size int16 :offset-assert 2) @@ -4488,16 +5736,14 @@ :size-assert #x10 :flag-assert #x900000010 ) -|# -;; (define-extern *screen-shot-work* object) -;; (define-extern *image-name* object) +(define-extern *screen-shot-work* screen-shot-work) +(define-extern *image-name* string) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; math-camera-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype vis-gif-tag (structure) ((fog0 uint32 :offset-assert 0) (strip uint32 :offset-assert 4) @@ -4508,9 +5754,7 @@ :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype cull-info (structure) ((x-fact float :offset-assert 0) (y-fact float :offset-assert 4) @@ -4529,17 +5773,16 @@ (yz-dir-bz float :offset-assert 56) (yz-cross-ab float :offset-assert 60) ) + :allow-misaligned :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 ) -|# -#| (deftype math-camera (basic) ((d meters :offset-assert 4) (f meters :offset-assert 8) - (fov deg :offset-assert 12) ;; degrees + (fov degrees :offset-assert 12) (x-ratio float :offset-assert 16) (y-ratio float :offset-assert 20) (x-pix float :offset-assert 24) @@ -4574,16 +5817,16 @@ (inv-hmge-scale vector :inline :offset-assert 800) (hvdf-off vector :inline :offset-assert 816) (guard vector :inline :offset-assert 832) - (vis-gifs vis-gif-tag 4 :offset-assert 848) ;; guessed by decompiler - (giftex uint128 :offset-assert 848) ;; vis-gif-tag - (gifgr uint128 :offset-assert 864) ;; vis-gif-tag - (giftex-trans uint128 :offset-assert 880) ;; vis-gif-tag - (gifgr-trans uint128 :offset-assert 896) ;; vis-gif-tag + (vis-gifs vis-gif-tag 4 :inline :offset-assert 848) ;; guessed by decompiler + (giftex uint128 :offset 848) ;; vis-gif-tag + (gifgr uint128 :offset 864) ;; vis-gif-tag + (giftex-trans uint128 :offset 880) ;; vis-gif-tag + (gifgr-trans uint128 :offset 896) ;; vis-gif-tag (pfog0 float :offset-assert 912) (pfog1 float :offset-assert 916) (trans vector :inline :offset-assert 928) - (plane plane 4 :offset-assert 944) ;; guessed by decompiler - (guard-plane plane 4 :offset-assert 1008) ;; guessed by decompiler + (plane plane 4 :inline :offset-assert 944) ;; guessed by decompiler + (guard-plane plane 4 :inline :offset-assert 1008) ;; guessed by decompiler (shrub-mat matrix :inline :offset-assert 1072) (quat-other quaternion :inline :offset-assert 1136) (trans-other vector :inline :offset-assert 1152) @@ -4591,8 +5834,8 @@ (camera-temp-other matrix :inline :offset-assert 1232) (camera-rot-other matrix :inline :offset-assert 1296) (inv-camera-rot-other matrix :inline :offset-assert 1360) - (plane-other UNKNOWN 4 :offset-assert 1424) - (guard-plane-other UNKNOWN 4 :offset-assert 1488) + (plane-other plane 4 :inline :offset-assert 1424) + (guard-plane-other plane 4 :inline :offset-assert 1488) (mirror-trans vector :inline :offset-assert 1552) (mirror-normal vector :inline :offset-assert 1568) (fov-correction-factor float :offset-assert 1584) @@ -4601,14 +5844,12 @@ :size-assert #x634 :flag-assert #x900000634 ) -|# ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; math-camera ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype fog-corrector (structure) ((fog-end float :offset-assert 0) (fog-start float :offset-assert 4) @@ -4617,37 +5858,33 @@ :size-assert #x8 :flag-assert #x900000008 ) -|# -;; (define-extern fog-corrector-setup object) ;; (function fog-corrector math-camera none) -;; (define-extern *math-camera-fog-correction* object) ;; fog-corrector -;; (define-extern update-math-camera object) ;; (function math-camera symbol symbol math-camera) -;; (define-extern *math-camera* object) ;; math-camera -;; (define-extern math-cam-start-smoothing object) ;; (function float float quaternion) -;; (define-extern move-target-from-pad object) ;; (function transform int transform) -;; (define-extern transform-point-vector! object) ;; (function vector vector symbol) -;; (define-extern transform-point-qword! object) ;; (function vector4w vector symbol) -;; (define-extern transform-point-vector-scale! object) ;; (function vector vector float) -;; (define-extern reverse-transform-point! object) -;; (define-extern init-for-transform object) ;; (function matrix none) +(define-extern fog-corrector-setup (function fog-corrector math-camera none)) +(define-extern *math-camera-fog-correction* fog-corrector) +(define-extern update-math-camera (function math-camera symbol symbol float math-camera)) +(define-extern *math-camera* math-camera) +(define-extern math-cam-start-smoothing (function float float quaternion)) +(define-extern move-target-from-pad (function transform int transform)) +(define-extern transform-point-vector! (function vector vector symbol)) +(define-extern transform-point-qword! (function vector4w vector symbol)) +(define-extern transform-point-vector-scale! (function vector vector float)) +(define-extern reverse-transform-point! (function vector vector vector vector none)) +(define-extern init-for-transform (function matrix none)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; font-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype char-verts (structure) - ((pos vector 4 :offset-assert 0) ;; guessed by decompiler - (color vector 4 :offset-assert 64) ;; guessed by decompiler - (tex-st vector 4 :offset-assert 128) ;; guessed by decompiler + ((pos vector 4 :inline :offset-assert 0) ;; guessed by decompiler + (color vector 4 :inline :offset-assert 64) ;; guessed by decompiler + (tex-st vector 4 :inline :offset-assert 128) ;; guessed by decompiler ) :method-count-assert 9 :size-assert #xc0 :flag-assert #x9000000c0 ) -|# -#| (deftype char-color (structure) ((color rgba 4 :offset-assert 0) ;; guessed by decompiler ) @@ -4655,9 +5892,16 @@ :size-assert #x10 :flag-assert #x900000010 ) -|# -#| +(defenum font-color + :type uint32 + ) + +(defenum font-flags + :type uint32 + :bitfield #t + ) + (deftype font-context (basic) ((origin vector :inline :offset-assert 16) (strip-gif vector :inline :offset-assert 32) @@ -4675,36 +5919,35 @@ :size-assert #x54 :flag-assert #x1500000054 (:methods - ;; (new (symbol type matrix int int float font-color font-flags) _type_ 0) - (dummy-9 () none 9) ;; (set-mat! (font-context matrix) font-context 9) - (dummy-10 () none 10) ;; (set-origin! (font-context int int) font-context 10) - (dummy-11 () none 11) ;; (set-depth! (font-context int) font-context 11) - (dummy-12 () none 12) ;; (set-w! (font-context float) font-context 12) - (dummy-13 () none 13) ;; (set-width! (font-context int) font-context 13) - (dummy-14 () none 14) ;; (set-height! (font-context int) font-context 14) - (dummy-15 () none 15) ;; (set-projection! (font-context float) font-context 15) - (dummy-16 () none 16) ;; (set-color! (font-context font-color) font-context 16) - (dummy-17 () none 17) ;; (set-flags! (font-context font-flags) font-context 17) - (dummy-18 () none 18) ;; (set-start-line! (font-context uint) font-context 18) - (dummy-19 () none 19) ;; (set-scale! (font-context float) font-context 19) - (dummy-20 () none 20) + (new (symbol type matrix int int int font-color font-flags) _type_ 0) + (set-mat! (font-context matrix) font-context 9) + (set-origin! (font-context int int) font-context 10) + (set-depth! (font-context int) font-context 11) + (set-w! (font-context float) font-context 12) + (set-width! (font-context int) font-context 13) + (set-height! (font-context int) font-context 14) + (set-projection! (font-context float) font-context 15) + (set-color! (font-context font-color) font-context 16) + (set-flags! (font-context font-flags) font-context 17) + (set-start-line! (font-context uint) font-context 18) + (set-scale! (font-context float) font-context 19) + (set-alpha! (font-context float) font-context 20) ) ) -|# -#| + (deftype font-work (structure) ((font-tmpl dma-gif-packet :inline :offset-assert 0) (char-tmpl dma-gif-packet :inline :offset-assert 32) (tex1-tmpl uint64 2 :offset-assert 64) ;; guessed by decompiler - (small-font-0-tmpl UNKNOWN 2 :offset-assert 80) - (small-font-1-tmpl UNKNOWN 2 :offset-assert 96) - (small-font-2-tmpl UNKNOWN 2 :offset-assert 112) - (small-font-3-tmpl UNKNOWN 2 :offset-assert 128) - (large-font-0-tmpl UNKNOWN 2 :offset-assert 144) - (large-font-1-tmpl UNKNOWN 2 :offset-assert 160) - (large-font-2-tmpl UNKNOWN 2 :offset-assert 176) - (large-font-3-tmpl UNKNOWN 2 :offset-assert 192) + (small-font-0-tmpl uint64 2 :offset-assert 80) + (small-font-1-tmpl uint64 2 :offset-assert 96) + (small-font-2-tmpl uint64 2 :offset-assert 112) + (small-font-3-tmpl uint64 2 :offset-assert 128) + (large-font-0-tmpl uint64 2 :offset-assert 144) + (large-font-1-tmpl uint64 2 :offset-assert 160) + (large-font-2-tmpl uint64 2 :offset-assert 176) + (large-font-3-tmpl uint64 2 :offset-assert 192) (size1-small vector :inline :offset-assert 208) (size2-small vector :inline :offset-assert 224) (size3-small vector :inline :offset-assert 240) @@ -4722,17 +5965,17 @@ (size-st2 vector :inline :offset-assert 432) (size-st3 vector :inline :offset-assert 448) (save vector :inline :offset-assert 464) - (save-color vector 4 :offset-assert 480) ;; guessed by decompiler + (save-color vector 4 :inline :offset-assert 480) ;; guessed by decompiler (current-verts char-verts :inline :offset-assert 544) (src-verts char-verts :inline :offset-assert 736) (dest-verts char-verts :inline :offset-assert 928) - (justify vector 64 :offset-assert 1120) ;; guessed by decompiler + (justify vector 64 :inline :offset-assert 1120) ;; guessed by decompiler (color-shadow vector4w :inline :offset-assert 2144) - (color-table char-color 40 :offset-assert 2160) ;; guessed by decompiler - (current-font-0-tmpl UNKNOWN 2 :offset-assert 2800) - (current-font-1-tmpl UNKNOWN 2 :offset-assert 2816) - (current-font-2-tmpl UNKNOWN 2 :offset-assert 2832) - (current-font-3-tmpl UNKNOWN 2 :offset-assert 2848) + (color-table char-color 40 :inline :offset-assert 2160) ;; guessed by decompiler + (current-font-0-tmpl uint64 2 :offset-assert 2800) + (current-font-1-tmpl uint64 2 :offset-assert 2816) + (current-font-2-tmpl uint64 2 :offset-assert 2832) + (current-font-3-tmpl uint64 2 :offset-assert 2848) (last-color font-color :offset-assert 2864) ;; guessed by decompiler (save-last-color font-color :offset-assert 2868) ;; guessed by decompiler (buf basic :offset-assert 2872) @@ -4744,10 +5987,10 @@ :size-assert #xb58 :flag-assert #x900000b58 ) -|# -;; (define-extern *font-default-matrix* object) ;; matrix -;; (define-extern *font-work* object) ;; font-work + +(define-extern *font-default-matrix* matrix) +(define-extern *font-work* font-work) ;; (define-extern font-set-tex0 object) ;; (function (pointer gs-tex0) texture uint uint uint none) ;; (define-extern set-font-color object) @@ -4801,9 +6044,9 @@ ;; display ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern get-current-time object) ;; (function time-frame) -;; (define-extern get-integral-current-time object) ;; (function time-frame) -;; (define-extern set-display object) ;; (function display int int int int int display) +(define-extern get-current-time (function time-frame)) +(define-extern get-integral-current-time (function time-frame)) +(define-extern set-display (function display int int int int int display)) ;; (define-extern allocate-dma-buffers object) ;; (function display display) ;; (define-extern *font-context* object) ;; font-context ;; (define-extern draw-sprite2d-xy object) ;; (function dma-buffer int int int int rgba none) @@ -5477,9 +6720,105 @@ ;; settings-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| +(defenum language-enum + :type int64 + (english) + (french) + (german) + (spanish) + (italian) + (japanese) + (korean) + (uk-english) + ) + (deftype user-setting-data (structure) - () + ((border-mode symbol) + (process-mask process-mask) + (language language-enum :offset 16) + (movie (pointer process) :offset 40) + (talking (pointer process)) + (spooling (pointer process)) + (hint (pointer process)) + (ambient (pointer process) :offset-assert 56) + (video-mode symbol) + (aspect-ratio symbol :offset-assert 64) + (auto-save symbol :offset 72) + (bg-r float :offset-assert 76) + (bg-g float) + (bg-b float) + (bg-a float) + (bg-a-speed float) + (bg-a-force float) + (allow-progress symbol :offset-assert 100) + (allow-pause symbol :offset-assert 104) + (movie-name symbol :offset 120) + (weather symbol :offset-assert 124) + (task-mask task-mask :offset 136) + (duck symbol :offset 144) + (attack symbol) + (gun symbol) + (board symbol) + (jump symbol) + (speed-mult float) + (features uint64) + (sfx-volume float) + (sfx-movie-volume float :offset-assert 180) + (music-volume float) + (music-volume-movie float) + (dialog-volume float) + (dialog-volume-hint float) + (ambient-volume float) + (ambient-volume-move float) + (sound-flava uint8) + (sound-flava-priority float :offset-assert 212) + (mode-sound-bank uint32) + (sound-excitement float) + (sound-reverb float) + (stereo-mode int32) + (music symbol) + (sound-stinger int32 :offset-assert 236) + (spool-anim symbol) + (sound-mode uint32) + (task-manager (pointer process)) + (task symbol) + (airlock symbol :offset-assert 256) + (minimap uint16) + (sound-tune uint32) + (allow-continue symbol) + (spotlight-color rgba) + (subtitle symbol :offset-assert 276) + (borrow symbol) + (doorway symbol) + (gen symbol) + (half-speed symbol) + (gun-buoy symbol) + (double-jump symbol) + (pilot symbol) + (pilot-exit symbol) + (exclusive-task int32 :offset-assert 312) + (speech-control symbol) + (vehicle-hijacking symbol) + (darkjak symbol) + (endlessfall symbol) + (rain float) + (snow float) + (exclusive-load symbol) + (render symbol) + (allow-timeout symbol) + (mirror symbol) + (movie-skip-frame float) + (allow-blackout symbol) + (race-minimap int32 :offset-assert 364) + (extra-bank symbol) + (beard symbol) + (ignore-target symbol) + (subtitle-language language-enum) + (sound-bank-load symbol) + (allow-error symbol) + (under-water-pitch-mod float :offset-assert 400) + (dummy object 31) + ) :method-count-assert 11 :size-assert #x210 :flag-assert #xb00000210 @@ -5489,11 +6828,105 @@ (dummy-10 () none 10) ) ) -|# -#| +(defenum cam-slave-options + :type uint64 + :bitfield #t + (BUTT_CAM) + (SAME_SIDE) + (MOVE_SPHERICAL) + (ALLOW_Z_ROT) + (JUMP_PITCHES) + (COLLIDE) + (FIND_HIDDEN_TARGET) + (DRAG) + (PLAYER_MOVING_CAMERA) + (LINE_OF_SIGHT) + (MOVEMENT_BLOCKED) + (SHRINK_MAX_ANGLE) + (GOTO_GOOD_POINT) + (BIKE_MODE) + (NO_ROTATE) + (STICKY_ANGLE) + (BLOCK_RIGHT_STICK) + (ALLOW_SHIFT_BUTTONS) + (GUN_CAM) + (WIDE_FOV) + (RAPID_TRACKING) + (EASE_SPLINE_IDX) + (VERTICAL_FOLLOW_MATCHES_CAMERA) + (HAVE_BUTT_HANDLE) + ) + +(defenum cam-master-options + :type uint64 + :bitfield #t + (HAVE_TARGET) ;; 1 + (SET_COMBINER_AXIS) ;; 2 + (FLIP_COMBINER) ;; 4 + (HAVE_EASE_TO_POS) ;; 8 + (IN_BASE_REGION) ;; 10 + (IGNORE_ANALOG) ;; 20 + (READ_BUTTONS) ;; 40 + (IMMEDIATE_STRING_MIN_MAX) ;; 80 + ) + (deftype cam-setting-data (structure) - () + ((fov degrees) + (pov-handle handle :offset 16) + (pov-bone int32) + (pov-offset vector :inline) + (string-default symbol :offset-assert 48) + (string-max-length meters) + (string-min-length meters) + (string-max-height meters) + (string-min-height meters) + (string-cliff-height meters) + (string-camera-ceiling meters) + (gun-max-height meters) + (gun-min-height meters) + (string-local-down vector :inline) + (slave-options cam-slave-options) + (matrix-blend-max-angle degrees :offset-assert 120) + (matrix-blend-max-partial float) + (string-spline-max-move meters) + (string-spline-accel meters) + (string-spline-max-move-player meters) + (string-spline-accel-player meters) + (string-startup-vector vector :inline) + (string-use-startup-vector symbol) + (look-at-point vector :inline :offset-assert 176) + (use-look-at-point symbol) + (target-height meters) + (foot-offset meters) + (head-offset meters) + (teleport-on-entity-change symbol) + (entity-name string) + (entity-or-mode-changed symbol) + (master-options cam-master-options) + (entity-mask uint32 :offset-assert 232) + (mode-name symbol) + (real-entity-name string) + (cam-mode symbol) + (interp-time uint32) + (no-intro symbol) + (use-point-of-interest symbol) + (point-of-interest vector :inline :offset-assert 272) + (handle-of-interest handle) + (mouse-tumble-point vector :inline) + (use-mouse-tumble-point symbol) + (mouse-input symbol) + (cpad1-skip-buttons symbol) + (butt-handle handle) + (butt-angle float) + (extra-follow-height float) + (1Tinterp-time-priority uint32) + (string-max-length-default symbol) + (string-min-length-default symbol) + (string-max-height-default symbol) + (string-min-height-default symbol :offset-assert 368) + (dummy object 102) + ) :method-count-assert 11 :size-assert #x30c :flag-assert #xb0000030c @@ -5503,9 +6936,8 @@ (dummy-10 () none 10) ) ) -|# -#| +(declare-type engine basic) (deftype setting-control (basic) ((user-current user-setting-data :inline :offset-assert 16) (user-target user-setting-data :inline :offset-assert 544) @@ -5517,7 +6949,7 @@ (engine-pers basic :offset-assert 3952) (engine-hi basic :offset-assert 3956) (sound-stinger-time uint64 :offset-assert 3960) - (sound-stinger-change-time UNKNOWN 4 :offset-assert 3968) + (sound-stinger-change-time uint64 4 :offset-assert 3968) (sound-excitement-change-time uint64 :offset-assert 4000) (sound-excitement-targ float :offset-assert 4008) (sound-excitement-level uint32 :offset-assert 4012) @@ -5539,7 +6971,6 @@ (dummy-18 () none 18) ) ) -|# ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -5689,7 +7120,6 @@ ;; main-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype frame-stats (structure) ((field-time time-frame 2 :offset-assert 0) ;; guessed by decompiler (field int32 :offset-assert 16) @@ -5698,18 +7128,16 @@ :size-assert #x14 :flag-assert #x900000014 ) -|# -#| (deftype screen-filter (basic) ((draw? basic :offset-assert 4) (bucket int32 :offset-assert 8) - (color vector :inline :offset-assert 16) ;; rgba + (color vector :inline :offset-assert 16) (color-src vector :inline :offset-assert 32) (color-dest vector :inline :offset-assert 48) (extra vector :inline :offset-assert 64) - (speed float :offset-assert 64) - (current-interp float :offset-assert 68) + (speed float :offset 64) + (current-interp float :offset 68) ) :method-count-assert 12 :size-assert #x50 @@ -5720,15 +7148,13 @@ (dummy-11 () none 11) ) ) -|# -#| (deftype col-rend (basic) - ((draw? basic :offset-assert 4) - (outline? basic :offset-assert 8) - (show-back-faces? basic :offset-assert 12) - (show-normals? basic :offset-assert 16) - (ghost-hidden? basic :offset-assert 20) + ((draw? symbol :offset-assert 4) + (outline? symbol :offset-assert 8) + (show-back-faces? symbol :offset-assert 12) + (show-normals? symbol :offset-assert 16) + (ghost-hidden? symbol :offset-assert 20) (show-only uint32 :offset-assert 24) (cspec uint32 :offset-assert 28) (track uint8 :offset-assert 32) @@ -5743,122 +7169,122 @@ (dummy-9 () none 9) ) ) -|# -;; (define-extern *stats-poly* object) ;; symbol -;; (define-extern *stats-memory* object) ;; symbol -;; (define-extern *stats-memory-short* object) ;; symbol -;; (define-extern *stats-memory-level-index* object) -;; (define-extern *stats-collide* object) ;; symbol -;; (define-extern *stats-bsp* object) ;; symbol -;; (define-extern *stats-buffer* object) ;; symbol -;; (define-extern *stats-target* object) ;; symbol -;; (define-extern *stats-profile-bars* object) -;; (define-extern *stats-perf* object) -;; (define-extern *artist-all-visible* object) ;; symbol -;; (define-extern *artist-flip-visible* object) ;; symbol -;; (define-extern *artist-fix-visible* object) ;; symbol -;; (define-extern *artist-fix-frustum* object) ;; symbol -;; (define-extern *artist-error-spheres* object) ;; symbol -;; (define-extern *artist-use-menu-subdiv* object) ;; symbol -;; (define-extern *display-profile* object) ;; symbol -;; (define-extern *display-sidekick-stats* object) ;; symbol -;; (define-extern *display-quad-stats* object) ;; symbol -;; (define-extern *display-tri-stats* object) ;; symbol -;; (define-extern *display-ground-stats* object) ;; symbol -;; (define-extern *display-collision-marks* object) ;; symbol -;; (define-extern *display-collide-cache* object) ;; symbol -;; (define-extern *display-render-collision* object) ;; symbol -;; (define-extern *display-hipri-collision-marks* object) ;; symbol -;; (define-extern *display-edge-collision-marks* object) ;; symbol -;; (define-extern *display-geo-marks* object) ;; symbol -;; (define-extern *display-target-marks* object) ;; symbol -;; (define-extern *target-rc-board-controls* object) -;; (define-extern *display-collide-history* object) ;; int -;; (define-extern *display-xyz-axes* object) ;; symbol -;; (define-extern *display-cam-collide-history* object) ;; symbol -;; (define-extern *record-cam-collide-history* object) ;; symbol -;; (define-extern *display-cam-master-marks* object) ;; symbol -;; (define-extern *display-cam-other* object) ;; symbol -;; (define-extern *display-camera-marks* object) ;; symbol -;; (define-extern *camera-no-mip-correction* object) ;; symbol -;; (define-extern *display-cam-los-info* object) ;; symbol -;; (define-extern *display-cam-los-debug* object) ;; symbol -;; (define-extern *display-cam-los-marks* object) ;; symbol -;; (define-extern *display-cam-coll-marks* object) ;; symbol -;; (define-extern *display-camera-info* object) ;; symbol -;; (define-extern *display-camera-old-stats* object) ;; symbol -;; (define-extern *display-camera-last-attacker* object) ;; symbol -;; (define-extern *display-file-info* object) ;; symbol -;; (define-extern *display-actor-marks* object) ;; symbol -;; (define-extern *display-sprite-info* object) ;; symbol -;; (define-extern *display-sprite-marks* object) -;; (define-extern *display-sprite-spheres* object) -;; (define-extern *display-entity-errors* object) ;; symbol -;; (define-extern *display-instance-info* object) ;; symbol -;; (define-extern *display-deci-count* object) ;; symbol -;; (define-extern *sync-dma* object) ;; symbol -;; (define-extern *display-strip-lines* object) ;; int -;; (define-extern *display-battle-marks* object) -;; (define-extern *display-joint-axes* object) -;; (define-extern *display-nav-marks* object) ;; symbol -;; (define-extern *display-nav-network* object) -;; (define-extern *display-path-marks* object) ;; symbol -;; (define-extern *display-vol-marks* object) ;; symbol -;; (define-extern *display-water-marks* object) ;; symbol -;; (define-extern *display-nav-mesh* object) -;; (define-extern *display-actor-pointer* object) -;; (define-extern *display-actor-vis* object) ;; symbol -;; (define-extern *display-actor-graph* object) ;; symbol -;; (define-extern *display-traffic-height-map* object) -;; (define-extern *display-trail-graph* object) -;; (define-extern *display-color-bars* object) -;; (define-extern *display-bug-report* object) -;; (define-extern *display-level-border* object) ;; symbol -;; (define-extern *display-memcard-info* object) ;; symbol -;; (define-extern *display-split-boxes* object) ;; symbol -;; (define-extern *display-split-box-info* object) ;; symbol -;; (define-extern *display-texture-distances* object) -;; (define-extern *display-texture-download* object) ;; symbol -;; (define-extern *display-art-control* object) ;; symbol -;; (define-extern *display-gui-control* object) -;; (define-extern *display-level-spheres* object) ;; symbol -;; (define-extern *time-of-day-fast* object) ;; symbol -;; (define-extern *display-iop-info* object) ;; symbol -;; (define-extern *ambient-sound-class* object) ;; symbol -;; (define-extern *slow-frame-rate* object) ;; symbol -;; (define-extern *display-region-marks* object) -;; (define-extern *execute-regions* object) -;; (define-extern *debug-pause* object) ;; symbol -;; (define-extern *debug-view-anims* object) -;; (define-extern *debug-unkillable* object) -;; (define-extern *debug-actor* object) -;; (define-extern *gun-marks* object) -;; (define-extern *bug-report-output-mode* object) -;; (define-extern *display-scene-control* object) -;; (define-extern *display-bot-marks* object) -;; (define-extern *display-race-marks* object) -;; (define-extern *race-record-path* object) -;; (define-extern *select-race* object) -;; (define-extern *select-race-path* object) -;; (define-extern *bot-record-path* object) -;; (define-extern *subdivide-draw-mode* object) ;; int -;; (define-extern *subdivide-scissor-draw-mode* object) -;; (define-extern *subdivide-foreground-draw-mode* object) -;; (define-extern *subdivide-ocean-draw-mode* object) -;; (define-extern *ocean-height-hack* object) -;; (define-extern *dproc* object) ;; process -;; (define-extern *run* object) ;; symbol -;; (define-extern *teleport* object) ;; symbol -;; (define-extern *teleport-count* object) ;; int -;; (define-extern *draw-hook* object) ;; (function none) -;; (define-extern *debug-hook* object) ;; (function none) -;; (define-extern *menu-hook* object) ;; (function debug-menu-context) -;; (define-extern *progress-hook* object) ;; (function none) -;; (define-extern *dma-timeout-hook* object) ;; (function none) -;; (define-extern *frame-stats* object) ;; frame-stats -;; (define-extern *col-rend* object) -;; (define-extern debug-actor? object) +(define-extern *stats-poly* symbol) +(define-extern *stats-memory* symbol) +(define-extern *stats-memory-short* symbol) +(define-extern *stats-memory-level-index* int) +(define-extern *stats-collide* symbol) +(define-extern *stats-bsp* symbol) +(define-extern *stats-buffer* symbol) +(define-extern *stats-target* symbol) +(define-extern *stats-profile-bars* symbol) +(define-extern *stats-perf* symbol) +(define-extern *artist-all-visible* symbol) +(define-extern *artist-flip-visible* symbol) +(define-extern *artist-fix-visible* symbol) +(define-extern *artist-fix-frustum* symbol) +(define-extern *artist-error-spheres* symbol) +(define-extern *artist-use-menu-subdiv* symbol) +(define-extern *display-profile* symbol) +(define-extern *display-sidekick-stats* symbol) +(define-extern *display-quad-stats* symbol) +(define-extern *display-tri-stats* symbol) +(define-extern *display-ground-stats* symbol) +(define-extern *display-collision-marks* symbol) +(define-extern *display-collide-cache* symbol) +(define-extern *display-render-collision* symbol) +(define-extern *display-hipri-collision-marks* symbol) +(define-extern *display-edge-collision-marks* symbol) +(define-extern *display-geo-marks* symbol) +(define-extern *display-target-marks* symbol) +(define-extern *target-rc-board-controls* symbol) +(define-extern *display-collide-history* int) +(define-extern *display-xyz-axes* symbol) +(define-extern *display-cam-collide-history* symbol) +(define-extern *record-cam-collide-history* symbol) +(define-extern *display-cam-master-marks* symbol) +(define-extern *display-cam-other* symbol) +(define-extern *display-camera-marks* symbol) +(define-extern *camera-no-mip-correction* symbol) +(define-extern *display-cam-los-info* symbol) +(define-extern *display-cam-los-debug* symbol) +(define-extern *display-cam-los-marks* symbol) +(define-extern *display-cam-coll-marks* symbol) +(define-extern *display-camera-info* symbol) +(define-extern *display-camera-old-stats* symbol) +(define-extern *display-camera-last-attacker* symbol) +(define-extern *display-file-info* symbol) +(define-extern *display-actor-marks* symbol) +(define-extern *display-sprite-info* symbol) +(define-extern *display-sprite-marks* symbol) +(define-extern *display-sprite-spheres* symbol) +(define-extern *display-entity-errors* symbol) +(define-extern *display-instance-info* symbol) +(define-extern *display-deci-count* symbol) +(define-extern *sync-dma* symbol) +(define-extern *display-strip-lines* int) +(define-extern *display-battle-marks* symbol) +(define-extern *display-joint-axes* symbol) +(define-extern *display-nav-marks* symbol) +(define-extern *display-nav-network* symbol) +(define-extern *display-path-marks* symbol) +(define-extern *display-vol-marks* symbol) +(define-extern *display-water-marks* symbol) +(define-extern *display-nav-mesh* symbol) +(define-extern *display-actor-pointer* symbol) +(define-extern *display-actor-vis* symbol) +(define-extern *display-actor-graph* symbol) +(define-extern *display-traffic-height-map* symbol) +(define-extern *display-trail-graph* symbol) +(define-extern *display-color-bars* symbol) +(define-extern *display-bug-report* symbol) +(define-extern *display-level-border* symbol) +(define-extern *display-memcard-info* symbol) +(define-extern *display-split-boxes* symbol) +(define-extern *display-split-box-info* symbol) +(define-extern *display-texture-distances* symbol) +(define-extern *display-texture-download* symbol) +(define-extern *display-art-control* symbol) +(define-extern *display-gui-control* symbol) +(define-extern *display-level-spheres* symbol) +(define-extern *time-of-day-fast* symbol) +(define-extern *display-iop-info* symbol) +(define-extern *ambient-sound-class* symbol) +(define-extern *slow-frame-rate* symbol) +(define-extern *display-region-marks* symbol) +(define-extern *execute-regions* symbol) +(define-extern *debug-pause* symbol) +(define-extern *debug-view-anims* symbol) +(define-extern *debug-unkillable* symbol) +(define-extern *debug-actor* object) +(define-extern *gun-marks* symbol) +(define-extern *bug-report-output-mode* symbol) +(define-extern *display-scene-control* int) +(define-extern *display-bot-marks* int) +(define-extern *display-race-marks* int) +(define-extern *race-record-path* symbol) +(define-extern *select-race* int) +(define-extern *select-race-path* int) +(define-extern *bot-record-path* int) +(define-extern *subdivide-draw-mode* int) +(define-extern *subdivide-scissor-draw-mode* int) +(define-extern *subdivide-foreground-draw-mode* int) +(define-extern *subdivide-ocean-draw-mode* int) +(define-extern *ocean-height-hack* int) +(define-extern *dproc* process) +(define-extern *run* symbol) +(define-extern *teleport* symbol) +(define-extern *teleport-count* int) +(define-extern *draw-hook* (function none)) +(define-extern *debug-hook* pair) +(declare-type debug-menu-context basic) +(define-extern *menu-hook* (function debug-menu-context)) +(define-extern *progress-hook* (function none)) +(define-extern *dma-timeout-hook* (function none)) +(define-extern *frame-stats* frame-stats) +(define-extern *col-rend* col-rend) +(define-extern debug-actor? (function object symbol)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; mspace-h ;; @@ -6272,6 +7698,9 @@ ;; game-task-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defenum game-task + :type uint8 + ) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; task-control-h ;; @@ -9273,7 +10702,6 @@ ;; game-info-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype game-bank (basic) ((life-max-default float :offset-assert 4) (life-start-default float :offset-assert 8) @@ -9285,15 +10713,20 @@ :size-assert #x18 :flag-assert #x900000018 ) -|# -#| +(deftype actor-id (uint32) + () + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + (deftype highscore-info (structure) ((flags uint8 :offset-assert 0) - (award-scores UNKNOWN 3 :offset-assert 4) - (bronze-score float :offset-assert 4) - (silver-score float :offset-assert 8) - (gold-score float :offset-assert 12) + (award-scores float 3 :offset-assert 4) + (bronze-score float :offset 4) + (silver-score float :offset 8) + (gold-score float :offset 12) ) :method-count-assert 10 :size-assert #x10 @@ -9302,9 +10735,7 @@ (dummy-9 () none 9) ) ) -|# -#| (deftype level-buffer-state (structure) ((name symbol :offset-assert 0) ;; guessed by decompiler (display? symbol :offset-assert 4) ;; guessed by decompiler @@ -9315,7 +10746,6 @@ :size-assert #x10 :flag-assert #x900000010 ) -|# #| (deftype load-state (basic) @@ -14556,22 +15986,21 @@ ;; entity-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype entity-perm (structure) ((user-object object 2 :offset-assert 0) ;; guessed by decompiler - (user-uint64 uint64 :offset-assert 0) - (user-float float 2 :offset-assert 0) ;; guessed by decompiler - (user-int32 int32 2 :offset-assert 0) ;; guessed by decompiler - (user-uint32 uint32 2 :offset-assert 0) ;; guessed by decompiler - (user-int16 int16 4 :offset-assert 0) ;; guessed by decompiler - (user-uint16 uint16 4 :offset-assert 0) ;; guessed by decompiler - (user-int8 int8 8 :offset-assert 0) ;; guessed by decompiler - (user-uint8 uint8 8 :offset-assert 0) ;; guessed by decompiler - (status uint16 :offset-assert 8) ;; entity-perm-status - (dummy uint8 1 :offset-assert 10) ;; guessed by decompiler - (task uint8 :offset-assert 11) ;; game-task - (aid actor-id :offset-assert 12) ;; guessed by decompiler - (quad uint128 :offset-assert 0) + (user-uint64 uint64 :offset 0) + (user-float float 2 :offset 0) ;; guessed by decompiler + (user-int32 int32 2 :offset 0) ;; guessed by decompiler + (user-uint32 uint32 2 :offset 0) ;; guessed by decompiler + (user-int16 int16 4 :offset 0) ;; guessed by decompiler + (user-uint16 uint16 4 :offset 0) ;; guessed by decompiler + (user-int8 int8 8 :offset 0) ;; guessed by decompiler + (user-uint8 uint8 8 :offset 0) ;; guessed by decompiler + (status uint16 :offset 8) ;; entity-perm-status + (dummy uint8 1 :offset 10) ;; guessed by decompiler + (task uint8 :offset 11) ;; game-task + (aid actor-id :offset 12) ;; guessed by decompiler + (quad uint128 :offset 0) ) :method-count-assert 10 :size-assert #x10 @@ -14580,11 +16009,23 @@ (dummy-9 () none 9) ;; (update-perm! (_type_ symbol entity-perm-status) _type_ 9) ) ) -|# -#| + (deftype entity-links (structure) - () + ((prev-link entity-links :offset-assert 0) + (next-link entity-links :offset-assert 4) + (entity entity :offset-assert 8) + (process process :offset-assert 12) + (level level :offset-assert 16) + (vis-id int32 :offset-assert 20) + (kill-mask task-mask :offset-assert 24) + (vis-dist meters :offset-assert 28) + (trans vector :inline :offset-assert 32) + (perm entity-perm :inline :offset-assert 48) + (status uint16 :offset 56) + (aid uint32 :offset 60) + (task uint8 :offset 59) + ) :method-count-assert 10 :size-assert #x40 :flag-assert #xa00000040 @@ -14593,7 +16034,7 @@ (dummy-9 () none 9) ;; (birth? (_type_ vector) symbol 9) ) ) -|# + #| (deftype entity-perm-array (inline-array-class) @@ -18099,7 +19540,7 @@ |# ;; (define-extern *sprite-distorter-sine-tables* object) ;; sprite-distorter-sine-tables -;; (define-extern sprite-distorter-generate-tables object) ;; (function none) +(define-extern sprite-distorter-generate-tables (function none)) ;; (define-extern sprite-distort-vu1-block object) ;; vu-function ;; (define-extern sprite-init-distorter object) ;; (function dma-buffer uint none) ;; (define-extern sprite-draw-distorters object) ;; (function dma-buffer none) @@ -18351,7 +19792,7 @@ ;; (define-extern history-draw-and-update object) ;; (function pos-history int vector symbol) ;; (define-extern dma-timeout-cam object) ;; (function vector) ;; (define-extern display-file-info object) ;; (function int) -;; (define-extern add-debug-cursor object) +(define-extern add-debug-cursor (function symbol bucket-id int int int none)) ;; (define-extern *boundary-polygon* object) ;; (inline-array lbvtx) ;; (define-extern init-boundary-regs object) ;; (function none) ;; (define-extern add-boundary-shader object) ;; (function texture-id dma-buffer none) @@ -19774,7 +21215,7 @@ ;; (define-extern drawable-load object) ;; (function drawable kheap drawable) ;; (define-extern art-load object) ;; (function string kheap art) ;; (define-extern art-group-load-check object) ;; (function string kheap int art-group) -;; (define-extern external-art-buffer-init object) +(define-extern external-art-buffer-init function) ;; (define-extern *preload-spool-anims* object) ;; symbol ;; (define-extern ja-play-spooled-anim object) ;; (function spool-anim art-joint-anim art-joint-anim (function process-drawable symbol) int :behavior process-drawable) ;; (define-extern ja-abort-spooled-anim object) ;; (function spool-anim art-joint-anim int int :behavior process-drawable) @@ -19927,8 +21368,8 @@ ;; settings ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern get-current-language object) -;; (define-extern *setting-control* object) ;; setting-control +(define-extern get-current-language (function language-enum)) +(define-extern *setting-control* setting-control) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; mood-tables ;; @@ -21257,9 +22698,9 @@ ;; (define-extern *print-login* object) ;; symbol ;; (define-extern load-buffer-resize object) ;; (define-extern level-update-after-load object) ;; (function level login-state level) -;; (define-extern bg object) ;; (function symbol int) -;; (define-extern play object) ;; (function symbol symbol int) -;; (define-extern play-boot object) +(define-extern bg (function symbol int)) +(define-extern play (function symbol symbol int)) +(define-extern play-boot (function none)) ;; (define-extern update-sound-banks object) ;; (function int) ;; (define-extern show-level object) ;; (function symbol int) (define-extern *default-level* level) @@ -22401,7 +23842,7 @@ ;; (define-extern vector<-cspace+vector! object) ;; (function vector cspace vector vector) ;; (define-extern cspace-children object) ;; (function process-drawable int pair) ;; (define-extern cspace-inspect-tree object) ;; (function process-drawable cspace int int object object) -;; (define-extern execute-math-engine object) ;; (function int) +(define-extern execute-math-engine (function int)) ;; (define-extern draw-joint-axes object) ;; (define-extern draw-root object) ;; (define-extern empty-state object) ;; (state process) @@ -23084,7 +24525,7 @@ ;; (define-extern reset-target-state object) ;; (function symbol target :behavior target) ;; (define-extern target-init object) ;; (define-extern tobot-init object) -;; (define-extern stop object) ;; (function symbol int) +(define-extern stop (function symbol int)) ;; (define-extern start object) ;; (function symbol continue-point target) ;; (define-extern tobot-start object) ;; (define-extern tobot-stop object) @@ -24089,27 +25530,27 @@ ;; main ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern set-letterbox-frames object) ;; (function time-frame none) +(define-extern set-letterbox-frames (function time-frame none)) ;; (define-extern letterbox object) ;; (function none) ;; (define-extern set-blackout-frames object) ;; (function time-frame none) ;; (define-extern blackout object) ;; (function none) ;; (define-extern paused? object) ;; (function symbol) ;; (define-extern movie? object) ;; (function symbol) ;; (define-extern demo? object) -;; (define-extern *last-master-mode* object) ;; symbol +(define-extern *last-master-mode* symbol) ;; (define-extern set-master-mode object) ;; (function symbol none) ;; (define-extern pause-allowed? object) ;; (function symbol) ;; (define-extern toggle-pause object) ;; (function int) -;; (define-extern *screen-filter* object) ;; screen-filter -;; (define-extern *cheat-temp* object) ;; (pointer int32) -;; (define-extern *master-exit* object) ;; symbol -;; (define-extern *progress-cheat* object) ;; symbol -;; (define-extern *first-boot* object) ;; symbol +(define-extern *screen-filter* screen-filter) +(define-extern *cheat-temp* (pointer int32)) +(define-extern *master-exit* symbol) +(define-extern *progress-cheat* symbol) +(define-extern *first-boot* symbol) ;; (define-extern main-cheats object) ;; (function int) ;; (define-extern end-display object) ;; (define-extern display-loop-main object) -;; (define-extern display-loop object) ;; (function int :behavior process) -;; (define-extern on object) ;; (function symbol process) +(define-extern display-loop (function int :behavior process)) +(define-extern on (function symbol process)) ;; (define-extern off object) ;; (function int) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -24233,6 +25674,7 @@ ) |# +(declare-type entity-actor entity) #| (deftype entity-actor (entity) () @@ -24268,7 +25710,7 @@ ;; (define-extern *compact-actors* object) ;; symbol ;; (define-extern *vis-actors* object) ;; symbol ;; (define-extern entity-by-name object) ;; (function string entity) -;; (define-extern entity-by-type object) ;; (function type entity-actor) +(define-extern entity-by-type (function type entity-actor)) ;; (define-extern entity-by-aid object) ;; (function uint entity) ;; (define-extern entity-actor-from-level-name object) ;; (define-extern entity-nav-mesh-by-aid object) diff --git a/decompiler/config/jak2/anonymous_function_types.jsonc b/decompiler/config/jak2/anonymous_function_types.jsonc index c9b62c03b6..1f91f9c9f9 100644 --- a/decompiler/config/jak2/anonymous_function_types.jsonc +++ b/decompiler/config/jak2/anonymous_function_types.jsonc @@ -6,5 +6,11 @@ [26, "(function process symbol)"], [23, "(function process symbol)"], [17, "(function process symbol)"] + ], + "level": [ + [5, "(function none)"] + ], + "main": [ + [3, "(function none :behavior process)"] ] } \ No newline at end of file diff --git a/decompiler/config/jak2/hacks.jsonc b/decompiler/config/jak2/hacks.jsonc index 5cb4904062..1d3d5f48ab 100644 --- a/decompiler/config/jak2/hacks.jsonc +++ b/decompiler/config/jak2/hacks.jsonc @@ -95,7 +95,15 @@ }, "blocks_ending_in_asm_branch": { + "closest-pt-in-triangle": [17], + // this one is all asm branches + "circle-circle-xz-intersect": [ + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 + ], + "find-knot-span": [0, 1, 2, 3, 5, 6, 7, 8, 9], + + "curve-evaluate!": [0, 2, 5, 6, 7, 8, 9] }, // Sometimes the game might use format strings that are fetched dynamically, diff --git a/decompiler/config/jak2/label_types.jsonc b/decompiler/config/jak2/label_types.jsonc index a782aa9df3..fad2c11641 100644 --- a/decompiler/config/jak2/label_types.jsonc +++ b/decompiler/config/jak2/label_types.jsonc @@ -24,5 +24,44 @@ ], "quaternion-h": [ ["L1", "quaternion"] + ], + "quaternion": [ + ["L85", "vector"], + ["L84", "vector"], + ["L83", "vector"], + ["L82", "vector"], + ["L81", "vector"], + ["L80", "vector"], + ["L79", "vector"], + ["L78", "vector"] + ], + "trigonometry": [ + ["L93", "vector"], + ["L92", "vector"], + ["L91", "vector"] + ], + "video-h": [ + ["L1", "video-params"] + ], + "geometry": [ + ["L132", "vector"] + ], + "texture-h": [ + ["L10", "texture-base"], + ["L9", "texture-base"], + ["L8", "texture-base"], + ["L7", "texture-base"], + ["L6", "texture-base"], + ["L5", "texture-base"] + ], + "texture-anim-h": [ + ["L1", "(pointer uint32)", 64] + ], + "main-h": [ + ["L3", "frame-stats"] + ], + "font-h": [ + ["L20", "matrix"], + ["L19", "font-work"] ] } \ No newline at end of file diff --git a/decompiler/config/jak2/stack_structures.jsonc b/decompiler/config/jak2/stack_structures.jsonc index a315e9cbb3..188f8acd8e 100644 --- a/decompiler/config/jak2/stack_structures.jsonc +++ b/decompiler/config/jak2/stack_structures.jsonc @@ -59,5 +59,208 @@ [80, "matrix"] ], "matrix-with-scale->quaternion": [[16, "matrix"]], + "quaternion-exp!": [[16, "vector"]], + "quaternion-slerp!": [[16, "vector"]], + "quaternion-zxy!": [ + [16, "vector"], + [32, "vector"], + [48, "vector"] + ], + "vector-x-quaternion!": [[16, "matrix"]], + "vector-y-quaternion!": [[16, "matrix"]], + "vector-z-quaternion!": [[16, "matrix"]], + "quaternion-x-angle": [[16, "vector"]], + "quaternion-y-angle": [[16, "vector"]], + "quaternion-z-angle": [[16, "vector"]], + "quaternion-rotate-local-x!": [[16, "quaternion"]], + "quaternion-rotate-local-y!": [[16, "quaternion"]], + "quaternion-rotate-local-z!": [[16, "quaternion"]], + "quaternion-rotate-y!": [[16, "quaternion"]], + "quaternion-rotate-x!": [ + [16, "quaternion"], + [32, "vector"] + ], + "quaternion-rotate-z!": [ + [16, "quaternion"], + [32, "vector"] + ], + "quaternion-delta-y": [ + [16, "vector"], + [32, "vector"] + ], + "quaternion-rotate-y-to-vector!": [ + [16, "quaternion"], + [32, "vector"], + [48, "quaternion"] + ], + "quaternion-xz-angle": [ + [16, "matrix"], + [80, "vector"] + ], + "vector-rotate-x!": [ + [16, "quaternion"], + [32, "matrix"] + ], + "vector-rotate-y!": [ + [16, "quaternion"], + [32, "matrix"] + ], + "vector-rotate-z!": [ + [16, "quaternion"], + [32, "matrix"] + ], + "quaternion-axis-angle!": [ + [16, "vector"] + ], + "quaternion-vector-angle!": [ + [16, "vector"] + ], + "quaternion-look-at!": [ + [16, "matrix"] + ], + "quaternion-pseudo-seek": [ + [16, "quaternion"], + [32, "quaternion"] + ], + "quaternion-smooth-seek!": [ + [16, ["inline-array", "quaternion", 2]] + ], + "eul->matrix": [[16, "vector"]], + "eul->quat": [[16, "matrix"]], + "quat->eul": [[16, "matrix"]], + + "vector-sincos!": [[16, "vector"]], + "vector-reflect-flat-gravity!": [[16, "vector"], [32, "vector"]], + "vector-line-distance": [ + [16, "vector"], + [32, "vector"], + [48, "vector"], + [64, "vector"] + ], + "vector-line-distance-point!": [ + [16, "vector"], + [32, "vector"], + [48, "vector"], + [64, "vector"] + ], + "forward-up-nopitch->inv-matrix": [[16, "vector"]], + "forward-up-nopitch->quaternion": [[16, "matrix"]], + "forward-up->quaternion": [ + [16, "matrix"], + [80, "vector"] + ], + "quaternion-from-two-vectors!": [[16, "vector"]], + "quaternion-from-two-vectors-max-angle!": [[16, "vector"]], + "matrix-from-two-vectors!": [[16, "vector"]], + "matrix-from-two-vectors-max-angle!": [[16, "vector"]], + "matrix-from-two-vectors-max-angle-partial!": [[16, "vector"]], + "matrix-from-two-vectors-partial-linear!": [[16, "vector"]], + "matrix-remove-z-rot": [ + [16, "vector"], + [32, "matrix"] + ], + "matrix-rot-diff!": [ + [16, "quaternion"], + [32, "quaternion"], + [48, "quaternion"] + ], + "quaternion-seek": [ + [16, "matrix"], + [80, "matrix"], + [144, "quaternion"] + ], + "vector-segment-overlap": [ + [16, "vector"], + [32, "vector"], + [48, "vector"], + [64, "vector"] + ], + "line-sphere-intersection?": [ + [16, "vector"], + [32, "vector"], + [48, "vector"] + ], + "forward-up->inv-matrix": [ + [16, "vector"] + ], + "quaternion-from-two-vectors-partial!": [ + [16, "vector"] + ], + "quaternion-from-two-vectors-max-angle-partial!": [ + [16, "vector"] + ], + "matrix-from-two-vectors-smooth!": [ + [16, "vector"] + ], + "matrix-from-two-vectors-the-long-way-smooth!": [ + [16, "vector"] + ], + "quaternion-from-two-vectors-smooth!": [ + [16, "matrix"] + ], + "vector-deg-seek": [[16, "matrix"]], + "vector-deg-slerp": [ + [16, "matrix"], + [80, "vector"], + [96, "vector"] + ], + "circle-test": [ + [16, "sphere"], + [32, "sphere"], + [48, "vector"], + [64, "vector"] + ], + "vector-vector-deg-slerp!": [ + [16, "vector"], + [32, "vector"], + [48, "quaternion"], + [64, "quaternion"], + [80, "quaternion"], + [96, "vector"] + ], + "vector-circle-tangent-new": [ + [16, "sphere"], + [32, "vector"], + [48, "vector"] + ], + "vector-circle-tangent": [ + [16, "sphere"], + [32, "vector"], + [48, "vector"], + [64, "vector"] + ], + "curve-length": [ + [16, "vector"], + [32, "vector"] + ], + "curve-closest-point": [ + [16, "vector"], + [32, "vector"] + ], + "closest-pt-in-triangle": [ + [16, "vector"], + [32, "vector"], + [48, "vector"] + ], + "vector-plane-distance": [[16, "vector"]], + "vector-smooth-seek!": [[16, "vector"]], + "vector-vector-angle-safe": [[16, "vector"], [32, "vector"]], + "move-target-from-pad": [ + [16, "vector"], + [32, "vector"], + [48, "matrix"] + ], + "reverse-transform-point!": [ + [16, "vector"], + [32, "vector"], + [48, "vector"] + ], + "init-for-transform": [ + [16, "matrix"], + [80, "matrix"], + [144, "vector4s-3"], + [192, "vector"], + [208, "vector4s-3"] + ], "placeholder-do-not-add-below!": [] } diff --git a/decompiler/config/jak2/type_casts.jsonc b/decompiler/config/jak2/type_casts.jsonc index 3955d37cdf..cb89fad732 100644 --- a/decompiler/config/jak2/type_casts.jsonc +++ b/decompiler/config/jak2/type_casts.jsonc @@ -86,8 +86,96 @@ [[0,33], "f0", "float"], [[0,33], "f1", "float"], [[0,33], "f2", "float"] - ], + "vector-x-quaternion!": [[10, "v1", "(pointer uint128)"]], + "vector-y-quaternion!": [[10, "v1", "(pointer uint128)"]], + "vector-z-quaternion!": [[10, "v1", "(pointer uint128)"]], + "dma-buffer-add-vu-function": [[[9, 33], "t2", "dma-packet"]], + "dma-buffer-add-buckets": [ + [[1, 4], "v1", "dma-bucket"], + [5, "v1", "pointer"], + [[9, 11], "v1", "dma-bucket"], + [11, "v1", "pointer"] + ], + "dma-buffer-patch-buckets": [ + [[6,8], "a0", "(inline-array dma-bucket)"], + [8, "a3", "pointer"], + [14, "a0", "(inline-array dma-bucket)"], + [3, "a0", "(inline-array dma-bucket)"], + [36, "a0", "(inline-array dma-bucket)"], + [10, "a0", "(inline-array dma-bucket)"], + [18, "a0", "(inline-array dma-bucket)"], + [[29,33], "a0", "dma-packet"], + [34, "a0", "(inline-array dma-bucket)"] + ], + "dma-bucket-insert-tag": [ + [[2, 6], "v1", "dma-bucket"], + [3, "a0", "dma-bucket"] + ], + + "disasm-vif-details": [ + [[62, 94], "s3", "(pointer uint32)"], + [[98, 130], "s3", "(pointer uint16)"], + [[134, 164], "s3", "(pointer uint32)"], + [[168, 198], "s3", "(pointer uint16)"], + [[202, 225], "s3", "(pointer uint16)"] + ], + "disasm-vif-tag": [ + [[81, 85], "t1", "vif-stcycl-imm"], + [242, "a0", "vif-unpack-imm"] + ], + "disasm-dma-list": [ + [25, "v1", "dma-tag"], + [153, "v1", "dma-packet"], + [189, "v1", "dma-packet"], + [229, "v1", "dma-packet"], + [258, "v1", "dma-packet"], + [302, "v1", "dma-packet"], + [308, "v1", "dma-packet"], + [152, "v1", "(pointer uint64)"], + [167, "v1", "(pointer uint64)"], + [176, "v1", "(pointer uint64)"], + [198, "v1", "(pointer uint64)"], + [207, "v1", "(pointer uint64)"], + [238, "v1", "(pointer uint64)"], + [247, "v1", "(pointer uint64)"], + [282, "v1", "(pointer uint64)"], + [291, "v1", "(pointer uint64)"], + [324, "v1", "(pointer uint64)"], + [334, "v1", "(pointer uint64)"] + ], + "calculate-basis-functions-vector!": [ + [[8, 20], "v1", "(pointer float)"], + [[0, 60], "f1", "float"] + ], + "curve-evaluate!": [[62, "s5", "pointer"]], + "vector4-array-add!": [ + [11, "s5", "(inline-array vector4)"], + [12, "s4", "(inline-array vector4)"], + [13, "gp", "(inline-array vector4)"]], + "vector4-array-sub!": [ + [11, "s5", "(inline-array vector4)"], + [12, "s4", "(inline-array vector4)"], + [13, "gp", "(inline-array vector4)"]], + "vector4-array-mul!": [ + [11, "s5", "(inline-array vector4)"], + [12, "s4", "(inline-array vector4)"], + [13, "gp", "(inline-array vector4)"]], + "vector4-array-scale!": [ + [11, "s5", "(inline-array vector4)"], + [12, "gp", "(inline-array vector4)"]], + "vector4-array-madd!": [ + [13, "s5", "(inline-array vector4)"], + [14, "s4", "(inline-array vector4)"], + [15, "gp", "(inline-array vector4)"]], + "vector4-array-msub!": [ + [13, "s5", "(inline-array vector4)"], + [14, "s4", "(inline-array vector4)"], + [15, "gp", "(inline-array vector4)"]], + "vector4-array-lerp!": [ + [13, "s5", "(inline-array vector4)"], + [14, "s4", "(inline-array vector4)"], + [15, "gp", "(inline-array vector4)"]], "placeholder-do-not-add-below": [] } diff --git a/decompiler/util/data_decompile.cpp b/decompiler/util/data_decompile.cpp index ea1edef0fd..2e5fa94011 100644 --- a/decompiler/util/data_decompile.cpp +++ b/decompiler/util/data_decompile.cpp @@ -924,7 +924,7 @@ goos::Object decompile_structure(const TypeSpec& type, } // first, let's see if it's a value or reference - auto field_type_info = ts.lookup_type(field.type()); + auto field_type_info = ts.lookup_type_allow_partial_def(field.type()); if (!field_type_info->is_reference()) { // value type. need to get bytes. ASSERT(!field.is_inline()); diff --git a/goal_src/jak2/engine/dma/dma-bucket.gc b/goal_src/jak2/engine/dma/dma-bucket.gc index 0d813359f6..de41a311db 100644 --- a/goal_src/jak2/engine/dma/dma-bucket.gc +++ b/goal_src/jak2/engine/dma/dma-bucket.gc @@ -5,3 +5,59 @@ ;; name in dgo: dma-bucket ;; dgos: ENGINE, GAME +(define-extern *display-profile* symbol) +(define-extern *stats-profile-bars* symbol) + +(defun dma-buffer-add-buckets ((arg0 dma-buffer) (arg1 int)) + (let ((v0-0 (-> arg0 base))) + (let ((v1-0 (the-as object v0-0))) + (dotimes (a2-0 arg1) + (set! (-> (the-as dma-bucket v1-0) tag) + (new 'static 'dma-tag :id (dma-tag-id next) :addr (the-as int (&+ (the-as pointer v1-0) 16))) + ) + (set! (-> (the-as dma-bucket v1-0) last) (the-as (pointer dma-tag) v1-0)) + (set! v1-0 (&+ (the-as pointer v1-0) 16)) + ) + (set! (-> arg0 base) (the-as pointer v1-0)) + ) + (the-as (inline-array dma-bucket) v0-0) + ) + ) + +(defun dma-buffer-patch-buckets ((arg0 (inline-array dma-bucket)) (arg1 int)) + (when (nonzero? arg0) + (dotimes (v1-1 arg1) + (cond + ((= (the-as object arg0) (-> arg0 0 last)) + (set! (-> arg0 0 tag) (new 'static 'dma-tag :id (dma-tag-id cnt))) + (set! (-> arg0 0 clear) (the-as uint 0)) + 0 + ) + (else + (set! (-> arg0 0 last 0 addr) (the-as int (-> arg0 1))) + (cond + ((or *display-profile* *stats-profile-bars*) + (set! (-> (the-as dma-packet arg0) vif0) (new 'static 'vif-tag :cmd (vif-cmd mark) :imm v1-1)) + (set! (-> (the-as dma-packet arg0) vif1) (new 'static 'vif-tag :irq #x1)) + ) + (else + (set! (-> arg0 0 clear) (the-as uint 0)) + 0 + ) + ) + ) + ) + (set! arg0 (the-as (inline-array dma-bucket) (-> arg0 1))) + ) + ) + (the-as (inline-array dma-bucket) arg0) + ) + +(defun dma-bucket-insert-tag ((arg0 (inline-array dma-bucket)) (arg1 bucket-id) (arg2 pointer) (arg3 (pointer dma-tag))) + (let ((v1-1 (-> arg0 arg1))) + (set! (-> (the-as dma-bucket (-> v1-1 last)) next) (the-as uint arg2)) + (set! (-> v1-1 last) arg3) + ) + arg2 + ) + diff --git a/goal_src/jak2/engine/dma/dma-buffer.gc b/goal_src/jak2/engine/dma/dma-buffer.gc index 2678e81e88..b9b86a02e7 100644 --- a/goal_src/jak2/engine/dma/dma-buffer.gc +++ b/goal_src/jak2/engine/dma/dma-buffer.gc @@ -5,3 +5,133 @@ ;; name in dgo: dma-buffer ;; dgos: ENGINE, GAME +(deftype dma-packet (structure) + ((dma dma-tag :offset-assert 0) + (vif0 vif-tag :offset-assert 8) + (vif1 vif-tag :offset-assert 12) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype dma-packet-array (inline-array-class) + ((data dma-packet :inline :dynamic :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) +(set! (-> dma-packet-array heap-base) (the-as uint 16)) + +(deftype dma-gif (structure) + ((gif uint64 2 :offset-assert 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype dma-gif-packet (structure) + ((dma-vif dma-packet :inline :offset-assert 0) + (gif uint64 2 :offset-assert 16) + (quad uint128 2 :offset 0) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(deftype dma-buffer (basic) + ((allocated-length int32 :offset-assert 4) + (base pointer :offset-assert 8) + (end pointer :offset-assert 12) + (data uint64 1 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x18 + :flag-assert #x900000018 + (:methods + (new (symbol type int) _type_ 0) + ) + ) + +(defmethod new dma-buffer ((allocation symbol) (type-to-make type) (arg0 int)) + (let ((v0-0 (object-new allocation type-to-make (+ arg0 -4 (-> type-to-make size))))) + (set! (-> v0-0 base) (-> v0-0 data)) + (set! (-> v0-0 allocated-length) arg0) + v0-0 + ) + ) + +(defun dma-buffer-inplace-new ((arg0 dma-buffer) (arg1 int)) + (set! (-> arg0 base) (-> arg0 data)) + (set! (-> arg0 allocated-length) arg1) + arg0 + ) + +(defmethod length dma-buffer ((obj dma-buffer)) + (-> obj allocated-length) + ) + +(defmethod asize-of dma-buffer ((obj dma-buffer)) + (+ (-> obj allocated-length) -4 (-> dma-buffer size)) + ) + +(defun dma-buffer-length ((arg0 dma-buffer)) + (the-as int (shr (+ (&- (-> arg0 base) (the-as uint (-> arg0 data))) 15) 4)) + ) + +(defun dma-buffer-free ((arg0 dma-buffer)) + (the-as int (shr (+ (&- (-> arg0 end) (the-as uint (-> arg0 base))) 15) 4)) + ) + +(defun dma-buffer-add-vu-function ((arg0 dma-buffer) (arg1 vu-function) (arg2 int)) + (let ((v1-0 (&-> arg1 data 4)) + (a3-0 (-> arg1 qlength)) + (a1-1 (-> arg1 origin)) + ) + (while (> a3-0 0) + (let ((t0-1 (min 127 a3-0))) + (let* ((t1-1 arg0) + (t2-0 (the-as object (-> t1-1 base))) + ) + (set! (-> (the-as dma-packet t2-0) dma) + (new 'static 'dma-tag :id (dma-tag-id ref) :addr (the-as int v1-0) :qwc t0-1) + ) + (set! (-> (the-as dma-packet t2-0) vif0) (new 'static 'vif-tag :cmd (if (zero? arg2) 16 19))) + (set! (-> (the-as dma-packet t2-0) vif1) (new 'static 'vif-tag :cmd (vif-cmd mpg) :num (* t0-1 2) :imm a1-1)) + (set! (-> t1-1 base) (&+ (the-as pointer t2-0) 16)) + ) + (&+! v1-0 (* t0-1 16)) + (set! a3-0 (- a3-0 t0-1)) + (+! a1-1 (* t0-1 2)) + ) + ) + ) + #f + ) + +(defun dma-buffer-send ((arg0 dma-bank) (arg1 dma-buffer)) + (when (< (-> arg1 allocated-length) (&- (-> arg1 base) (the-as uint (-> arg1 data)))) + (crash!) + 0 + ) + (dma-send arg0 (the-as uint (-> arg1 data)) (the-as uint (dma-buffer-length arg1))) + (none) + ) + +(defun dma-buffer-send-chain ((arg0 dma-bank-source) (arg1 dma-buffer)) + (when (< (-> arg1 allocated-length) (&- (-> arg1 base) (the-as uint (-> arg1 data)))) + (crash!) + 0 + ) + (dma-send-chain arg0 (the-as uint (-> arg1 data))) + (none) + ) + + + + diff --git a/goal_src/jak2/engine/dma/dma-disasm.gc b/goal_src/jak2/engine/dma/dma-disasm.gc index 21518eedfc..f79930a302 100644 --- a/goal_src/jak2/engine/dma/dma-disasm.gc +++ b/goal_src/jak2/engine/dma/dma-disasm.gc @@ -5,3 +5,580 @@ ;; name in dgo: dma-disasm ;; dgos: ENGINE, GAME +(declare-file (debug)) +(when *debug-segment* + +(deftype vif-disasm-element (structure) + ((mask uint32 :offset-assert 0) + (tag vif-cmd-32 :offset-assert 4) + (val uint32 :offset-assert 8) + (print uint32 :offset-assert 12) + (string1 string :offset-assert 16) + (string2 string :offset-assert 20) + ) + :method-count-assert 9 + :size-assert #x18 + :flag-assert #x900000018 + ) + + +(define *vif-disasm-table* + (the-as (array vif-disasm-element) + (new 'static 'boxed-array :type vif-disasm-element + (new 'static 'vif-disasm-element :mask #x7f :string1 "nop") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 stcycl) :print #x2 :string1 "stcycl") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 offset) :print #x1 :string1 "offset":string2 "offset") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 base) :print #x1 :string1 "base" :string2 "base") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 itop) :print #x1 :string1 "itop" :string2 "addr") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 stmod) :print #x1 :string1 "stmod" :string2 "mode") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 mskpath3) :print #x1 :string1 "mskpath3" :string2 "mask") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 mark) :print #x1 :string1 "mark" :string2 "mark") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 flushe) :string1 "flushe") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 flush) :string1 "flush") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 flusha) :string1 "flusha") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 mscal) :print #x1 :string1 "mscal" :string2 "addr") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 mscnt) :string1 "mscnt") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 mscalf) :print #x1 :string1 "mscalf" :string2 "addr") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 stmask) :print #x3 :string1 "stmask" :string2 "mask") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 strow) :print #x4 :string1 "strow" :string2 "row") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 stcol) :print #x4 :string1 "stcol" :string2 "col") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 mpg) :print #x5 :string1 "mpg") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 direct) :print #x6 :string1 "direct") + (new 'static 'vif-disasm-element :mask #x7f :tag (vif-cmd-32 directhl) :print #x6 :string1 "directhl") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-s-32) :val #x10 :print #x7 :string1 "unpack-s-32") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-s-16) :val #x8 :print #x7 :string1 "unpack-s-16") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-s-8) :val #x4 :print #x7 :string1 "unpack-s-8") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-v2-32) :val #x8 :print #x7 :string1 "unpack-v2-32") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-v2-16) :val #x4 :print #x7 :string1 "unpack-v2-16") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-v2-8) :val #x2 :print #x7 :string1 "unpack-v2-8") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-v3-32) :val #xc :print #x7 :string1 "unpack-v3-32") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-v3-16) :val #x6 :print #x7 :string1 "unpack-v3-16") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-v3-8) :val #x3 :print #x7 :string1 "unpack-v3-8") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-v4-32) :val #x10 :print #x7 :string1 "unpack-v4-32") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-v4-16) :val #x8 :print #x7 :string1 "unpack-v4-16") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-v4-8) :val #x4 :print #x7 :string1 "unpack-v4-8") + (new 'static 'vif-disasm-element :mask #x6f :tag (vif-cmd-32 unpack-v4-5) :val #x2 :print #x7 :string1 "unpack-v4-5") + (new 'static 'vif-disasm-element :print #x8) + ) + ) + ) + +(defun disasm-vif-details ((arg0 symbol) (arg1 (pointer uint8)) (arg2 vif-cmd) (arg3 int)) + (let ((s4-0 arg3)) + (cond + ((= arg2 (vif-cmd unpack-v4-8)) + (let ((s3-0 (&-> arg1 4))) + (dotimes (s2-0 s4-0) + (format + arg0 + " #x~X: #x~2X #x~2X #x~2X #x~2X~%" + (+ (+ (* s2-0 4) 4) (the-as int arg1)) + (-> s3-0 (* s2-0 4)) + (-> s3-0 (+ (* s2-0 4) 1)) + (-> s3-0 (+ (* s2-0 4) 2)) + (-> s3-0 (+ (* s2-0 4) 3)) + ) + ) + ) + ) + ((= arg2 (vif-cmd unpack-s-8)) + (let ((s3-1 (&-> arg1 4))) + (dotimes (s2-1 s4-0) + (format arg0 " #x~X: #x~2x~%" (+ (+ s2-1 4) (the-as int arg1)) arg3) + (-> s3-1 (* 3 s2-1)) + (-> s3-1 (+ (* 3 s2-1) 1)) + ) + ) + ) + ((= arg2 (vif-cmd unpack-v4-32)) + (let ((s3-2 (the-as (pointer uint32) (&-> arg1 4)))) + (dotimes (s2-2 s4-0) + (format + arg0 + " #x~X: #x~8x #x~8x #x~8x #x~8x~%" + (+ (+ (* s2-2 16) 4) (the-as int arg1)) + (-> s3-2 (* s2-2 4)) + (-> s3-2 (+ (* s2-2 4) 1)) + (-> s3-2 (+ (* s2-2 4) 2)) + (-> s3-2 (+ (* s2-2 4) 3)) + ) + ) + ) + ) + ((= arg2 (vif-cmd unpack-v4-16)) + (let ((s3-3 (the-as (pointer uint16) (&-> arg1 4)))) + (dotimes (s2-3 s4-0) + (format + arg0 + " #x~X: #x~4x #x~4x #x~4x #x~4x~%" + (+ (+ (* s2-3 8) 4) (the-as int arg1)) + (-> s3-3 (* s2-3 4)) + (-> s3-3 (+ (* s2-3 4) 1)) + (-> s3-3 (+ (* s2-3 4) 2)) + (-> s3-3 (+ (* s2-3 4) 3)) + ) + ) + ) + ) + ((= arg2 (vif-cmd unpack-v3-32)) + (let ((s3-4 (the-as (pointer uint32) (&-> arg1 4)))) + (dotimes (s2-4 s4-0) + (format + arg0 + " #x~X: #x~8x #x~8x #x~8x~%" + (+ (+ (* 12 s2-4) 4) (the-as int arg1)) + (-> (&+ s3-4 (* 12 s2-4)) 0) + (-> s3-4 (+ (* 3 s2-4) 1)) + (-> s3-4 (+ (* 3 s2-4) 2)) + ) + ) + ) + ) + ((= arg2 (vif-cmd unpack-v3-16)) + (let ((s3-5 (the-as (pointer uint16) (&-> arg1 4)))) + (dotimes (s2-5 s4-0) + (format + arg0 + " #x~X: #x~4x #x~4x #x~4x~%" + (+ (+ (* 6 s2-5) 4) (the-as int arg1)) + (-> (&+ s3-5 (* 6 s2-5)) 0) + (-> s3-5 (+ (* 3 s2-5) 1)) + (-> s3-5 (+ (* 3 s2-5) 2)) + ) + ) + ) + ) + ((= arg2 (vif-cmd unpack-v2-16)) + (let ((s3-6 (the-as (pointer uint16) (&-> arg1 4)))) + (dotimes (s2-6 s4-0) + (format + arg0 + " #x~X: #x~4x #x~4x~%" + (+ (+ (* s2-6 4) 4) (the-as int arg1)) + (-> (&+ s3-6 (* 6 s2-6)) 0) + (-> s3-6 (+ (* 3 s2-6) 1)) + ) + ) + ) + ) + (else + (format arg0 " #x~X: Data format #b~b not yet supported, add it for yourself!~%" (&-> arg1 4) arg2) + ) + ) + ) + #f + ) + +(defun disasm-vif-tag ((arg0 (pointer vif-tag)) (arg1 int) (arg2 symbol) (arg3 symbol)) + (local-vars (sv-16 vif-cmd) (sv-32 (pointer vif-tag)) (sv-48 int) (sv-64 vif-unpack-imm)) + (let ((gp-0 0)) + (while (< gp-0 (* arg1 4)) + (let ((s0-0 4)) + (let ((s1-0 (-> arg0 0))) + (format arg2 " #x~X:" arg0) + (dotimes (v1-0 (-> *vif-disasm-table* length)) + (set! sv-16 (-> s1-0 cmd)) + (when (= (logand sv-16 (-> *vif-disasm-table* v1-0 mask)) (-> *vif-disasm-table* v1-0 tag)) + (let ((a0-12 (-> *vif-disasm-table* v1-0 print))) + (cond + ((zero? a0-12) + (format arg2 " (~s :irq ~D)~%" (-> *vif-disasm-table* v1-0 string1) (-> s1-0 irq)) + ) + ((= a0-12 1) + (format + arg2 + " (~s :irq ~D :~s #x~X)~%" + (-> *vif-disasm-table* v1-0 string1) + (-> s1-0 irq) + (-> *vif-disasm-table* v1-0 string2) + (-> s1-0 imm) + ) + ) + ((= a0-12 2) + (let ((t1-1 (-> s1-0 imm))) + (format + arg2 + " (~s :irq ~D :wl ~D :cl ~D)~%" + (-> *vif-disasm-table* v1-0 string1) + (-> s1-0 irq) + (shr (shl (the-as int t1-1) 48) 56) + (shr (shl (the-as int t1-1) 56) 56) + ) + ) + ) + ((= a0-12 3) + (set! s0-0 8) + (format + arg2 + " (~s :irq ~D :~s #x~X)~%" + (-> *vif-disasm-table* v1-0 string1) + (-> s1-0 irq) + (-> *vif-disasm-table* v1-0 string2) + (-> arg0 1) + ) + ) + ((= a0-12 4) + (set! s0-0 20) + (format + arg2 + " (~s :irq ~D :~s " + (-> *vif-disasm-table* v1-0 string1) + (-> s1-0 irq) + (-> *vif-disasm-table* v1-0 string2) + ) + (format arg2 "#x~X #x~X #x~X #x~X)~%" (-> arg0 1) (-> arg0 2) (-> arg0 3) (-> arg0 4)) + ) + ((= a0-12 5) + (format + arg2 + " (~s :irq ~D :instructions #x~D :addr #x~X)~%" + (-> *vif-disasm-table* v1-0 string1) + (-> s1-0 irq) + (-> s1-0 num) + (-> s1-0 imm) + ) + ) + ((= a0-12 6) + (if (-> s1-0 imm) + (set! s0-0 #x100000) + (set! s0-0 (the-as int (* (-> s1-0 imm) 16))) + ) + (format arg2 " (~s :irq ~D :qwc #x~D)~%" (-> *vif-disasm-table* v1-0 string1) (-> s1-0 irq) (-> s1-0 imm)) + (set! sv-32 (&-> arg0 1)) + (set! sv-48 0) + (while (< sv-48 (the-as int (-> s1-0 imm))) + (format + arg2 + " #x~X: #x~8x #x~8x #x~8x #x~8x~%" + (+ (+ (* sv-48 16) 4) (the-as int arg0)) + (-> sv-32 (* sv-48 4)) + (-> sv-32 (+ (* sv-48 4) 1)) + (-> sv-32 (+ (* sv-48 4) 2)) + (-> sv-32 (+ (* sv-48 4) 3)) + ) + (set! sv-48 (+ sv-48 1)) + ) + #f + ) + ((= a0-12 7) + (set! s0-0 (the-as int (+ (logand -4 (+ (* (-> *vif-disasm-table* v1-0 val) (-> s1-0 num)) 3)) 4))) + (set! sv-64 (the-as vif-unpack-imm (-> s1-0 imm))) + (format + arg2 + " (~s :irq ~D :num ~D :addr #x~X " + (-> *vif-disasm-table* v1-0 string1) + (-> s1-0 irq) + (-> s1-0 num) + (-> sv-64 addr) + ) + (format + arg2 + ":msk ~D :flg ~D :usn ~D [skip ~d])~%" + (-> s1-0 msk) + (-> sv-64 flg) + (-> sv-64 usn) + (the-as uint s0-0) + ) + (if arg3 + (disasm-vif-details + arg2 + (the-as (pointer uint8) arg0) + (logand sv-16 (vif-cmd cmd-mask)) + (the-as int (-> s1-0 num)) + ) + ) + ) + ((= a0-12 8) + (format arg2 " (*unknown* vif-tag #x~X)~%" (-> s1-0 cmd)) + ) + ) + ) + (set! v1-0 (-> *vif-disasm-table* length)) + ) + ) + ) + (+! gp-0 s0-0) + (&+! arg0 s0-0) + ) + ) + (- gp-0 (* arg1 4)) + ) + ) + +(defun disasm-dma-tag ((arg0 dma-tag) (arg1 symbol)) + (format arg1 "(dma-tag ") + (let ((t9-1 format) + (a0-2 arg1) + (a1-2 "~s") + (v1-1 (-> arg0 id)) + ) + (t9-1 a0-2 a1-2 (cond + ((= v1-1 (dma-tag-id refe)) + "refe" + ) + ((= v1-1 (dma-tag-id refs)) + "refs" + ) + ((= v1-1 (dma-tag-id ret)) + "ret" + ) + ((= v1-1 (dma-tag-id cnt)) + "cnt" + ) + ((= v1-1 (dma-tag-id next)) + "next" + ) + ((= v1-1 (dma-tag-id call)) + "call" + ) + ((= v1-1 (dma-tag-id ref)) + "ref" + ) + ((= v1-1 (dma-tag-id end)) + "end" + ) + (else + "*unknown*" + ) + ) + ) + ) + (if (> (-> arg0 addr) 0) + (format arg1 " :addr #x~8x" (-> arg0 addr)) + ) + (if (> (-> arg0 qwc) 0) + (format arg1 " :qwc ~d" (-> arg0 qwc)) + ) + (if (> (-> arg0 spr) 0) + (format arg1 " :spr ~d" (-> arg0 spr)) + ) + (if (> (-> arg0 irq) 0) + (format arg1 " :irq ~d" (-> arg0 irq)) + ) + (if (> (-> arg0 pce) 0) + (format arg1 " :pce ~d" (-> arg0 pce)) + ) + (format arg1 ")~%") + (none) + ) + +(define *dma-disasm* #t) + +(defun disasm-dma-list ((arg0 dma-packet) (arg1 symbol) (arg2 symbol) (arg3 symbol) (arg4 int)) + (local-vars + (sv-16 object) + (sv-32 dma-packet) + (sv-48 int) + (sv-64 object) + (sv-80 object) + (sv-96 int) + (sv-112 dma-tag) + ) + (set! sv-32 arg0) + (let ((s2-0 arg1) + (s3-0 arg2) + (gp-0 arg3) + (s1-0 arg4) + ) + (if s3-0 + (format gp-0 "~%--- ~X -----------------------------~%" sv-32) + ) + (let ((s0-0 #f)) + (let ((s4-0 0) + (s5-0 0) + ) + (set! sv-16 0) + (set! sv-48 0) + (set! sv-64 0) + (set! sv-80 1) + (set! sv-96 -1) + (set! sv-112 (new 'static 'dma-tag)) + (while (not s0-0) + (let ((t9-1 valid?) + (a0-2 sv-32) + (a1-2 #f) + (a2-2 "dma-list tag pointer") + ) + (cond + ((not (t9-1 a0-2 (the-as type a1-2) (the-as symbol a2-2) #t gp-0)) + (format gp-0 "ERROR: dma-list tag pointer invalid~%") + (set! s0-0 'error) + ) + (else + (set! sv-112 (-> sv-32 dma)) + (when (not (or (zero? s5-0) (let ((t9-3 valid?) + (a0-4 sv-16) + (a1-4 #f) + ) + (set! a2-2 "dma-list data pointer") + (t9-3 a0-4 (the-as type a1-4) (the-as symbol a2-2) #t gp-0) + ) + ) + ) + (format gp-0 "ERROR: dma-list data pointer invalid~%") + (set! s0-0 'error) + ) + (when (logtest? (the-as dma-tag #x3ff0000) sv-112) + (format gp-0 "ERROR: dma tag has data in reserved bits ~X~%" (the-as none a2-2)) + (set! s0-0 'error) + ) + ) + ) + ) + (when (or s3-0 (= s0-0 'error)) + (format gp-0 "#x~8x: " sv-32) + (cond + ((zero? sv-96) + (format gp-0 " ") + ) + ((= sv-96 1) + (format gp-0 " ") + ) + ) + (disasm-dma-tag sv-112 gp-0) + ) + (cond + (s0-0 + ) + ((or (= (-> sv-112 id) (dma-tag-id ref)) (= (-> sv-112 id) (dma-tag-id refs)) (zero? (-> sv-112 id))) + (set! sv-16 (-> sv-112 addr)) + (set! sv-48 (the-as int (-> sv-112 qwc))) + (when s2-0 + (let ((v0-10 (disasm-vif-tag (&-> sv-32 vif0) 2 gp-0 (= s2-0 'details)))) + (disasm-vif-tag + (the-as (pointer vif-tag) (+ (the-as int sv-16) v0-10)) + (the-as int (- (* sv-48 4) (the-as uint (/ v0-10 4)))) + gp-0 + (= s2-0 'details) + ) + ) + ) + (set! sv-32 (the-as dma-packet (&-> (the-as (pointer uint64) sv-32) 2))) + (if (= (-> sv-112 id) (dma-tag-id refe)) + (set! s0-0 #t) + ) + ) + ((= (-> sv-112 id) (dma-tag-id cnt)) + (set! sv-16 (&-> (the-as (pointer uint64) sv-32) 2)) + (set! sv-48 (the-as int (-> sv-112 qwc))) + (if s2-0 + (disasm-vif-tag + (the-as (pointer vif-tag) (&-> (the-as (pointer uint64) sv-32) 1)) + (the-as int (+ (* sv-48 4) 2)) + gp-0 + (= s2-0 'details) + ) + ) + (set! sv-32 (the-as dma-packet (+ (the-as uint sv-32) (* (+ sv-48 1) 16)))) + sv-32 + ) + ((= (-> sv-112 id) (dma-tag-id next)) + (set! sv-16 (&-> (the-as (pointer uint64) sv-32) 2)) + (set! sv-48 (the-as int (-> sv-112 qwc))) + (if s2-0 + (disasm-vif-tag + (the-as (pointer vif-tag) (&-> (the-as (pointer uint64) sv-32) 1)) + (the-as int (+ (* sv-48 4) 2)) + gp-0 + (= s2-0 'details) + ) + ) + (when (= sv-32 (-> sv-112 addr)) + (format gp-0 "ERROR: next tag creates infinite loop.~%") + (set! s0-0 'error) + ) + (set! sv-32 (the-as dma-packet (-> sv-112 addr))) + sv-32 + ) + ((= (-> sv-112 id) (dma-tag-id call)) + (set! sv-16 (&-> (the-as (pointer uint64) sv-32) 2)) + (set! sv-48 (the-as int (-> sv-112 qwc))) + (if s2-0 + (disasm-vif-tag + (the-as (pointer vif-tag) (&-> (the-as (pointer uint64) sv-32) 1)) + (the-as int (+ (* sv-48 4) 2)) + gp-0 + (= s2-0 'details) + ) + ) + (set! sv-32 (the-as dma-packet (-> sv-112 addr))) + (set! sv-96 (+ sv-96 1)) + (cond + ((zero? sv-96) + (set! sv-64 (&+ (the pointer sv-16) sv-48)) + (the-as (pointer uint64) sv-64) + ) + (else + (set! sv-80 (&+ (the pointer sv-16) sv-48)) + (the-as (pointer uint64) sv-80) + ) + ) + ) + ((= (-> sv-112 id) (dma-tag-id ret)) + (set! sv-16 (&-> (the-as (pointer uint64) sv-32) 2)) + (set! sv-48 (the-as int (-> sv-112 qwc))) + (if s2-0 + (disasm-vif-tag + (the-as (pointer vif-tag) (&-> (the-as (pointer uint64) sv-32) 1)) + (the-as int (+ (* sv-48 4) 2)) + gp-0 + (= s2-0 'details) + ) + ) + (let ((v1-123 sv-96)) + (cond + ((zero? v1-123) + (set! sv-32 (the-as dma-packet sv-64)) + sv-32 + ) + ((= v1-123 1) + (set! sv-32 (the-as dma-packet sv-80)) + sv-32 + ) + (else + (set! s0-0 #t) + ) + ) + ) + (set! sv-96 (+ sv-96 -1)) + sv-96 + ) + ((= (-> sv-112 id) (dma-tag-id end)) + (set! sv-16 (&-> (the-as (pointer uint64) sv-32) 2)) + (set! sv-48 (the-as int (-> sv-112 qwc))) + (set! s0-0 #t) + (if s2-0 + (disasm-vif-tag + (the-as (pointer vif-tag) (&-> (the-as (pointer uint64) sv-32) 1)) + (the-as int (+ (* sv-48 4) 2)) + gp-0 + (= s2-0 'details) + ) + ) + ) + (else + (format gp-0 "ERROR: Unknown DMA TAG command.~%") + (set! s0-0 'error) + ) + ) + (+! s4-0 sv-48) + (+! s5-0 1) + (if (and (>= s1-0 0) (>= s5-0 s1-0)) + (set! s0-0 #t) + ) + ) + (when (or s3-0 (= s0-0 'error)) + (format gp-0 "NOTICE: Total tags: ~d~%" s5-0) + (format gp-0 "NOTICE: Total QWC: ~d~%" s4-0) + (format gp-0 "--------------------------------~%~%") + ) + ) + (!= s0-0 'error) + ) + ) + ) + +) + + + diff --git a/goal_src/jak2/engine/dma/dma-h.gc b/goal_src/jak2/engine/dma/dma-h.gc index 868c1cfdaa..d7237b48eb 100644 --- a/goal_src/jak2/engine/dma/dma-h.gc +++ b/goal_src/jak2/engine/dma/dma-h.gc @@ -5,3 +5,267 @@ ;; name in dgo: dma-h ;; dgos: ENGINE, GAME +(deftype dma-chcr (uint32) + ((dir uint8 :offset 0 :size 1) + (mod uint8 :offset 2 :size 2) + (asp uint8 :offset 4 :size 2) + (tte uint8 :offset 6 :size 1) + (tie uint8 :offset 7 :size 1) + (str uint8 :offset 8 :size 1) + (tag uint16 :offset 16 :size 16) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype dma-bank (structure) + ((chcr dma-chcr :offset 0) + (madr uint32 :offset 16) + (qwc uint32 :offset 32) + ) + :method-count-assert 9 + :size-assert #x24 + :flag-assert #x900000024 + ) + +(deftype dma-bank-source (dma-bank) + ((tadr uint32 :offset 48) + ) + :method-count-assert 9 + :size-assert #x34 + :flag-assert #x900000034 + ) + +(deftype dma-bank-vif (dma-bank-source) + ((as0 uint32 :offset 64) + (as1 uint32 :offset 80) + ) + :method-count-assert 9 + :size-assert #x54 + :flag-assert #x900000054 + ) + +(deftype dma-bank-spr (dma-bank-source) + ((sadr uint32 :offset 128) + ) + :method-count-assert 9 + :size-assert #x84 + :flag-assert #x900000084 + ) + +(deftype dma-ctrl (uint32) + ((dmae uint8 :offset 0 :size 1) + (rele uint8 :offset 1 :size 1) + (mfd uint8 :offset 2 :size 2) + (sts uint8 :offset 4 :size 2) + (std uint8 :offset 6 :size 2) + (rcyc uint8 :offset 8 :size 3) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype dma-enable (uint32) + ((cpnd uint8 :offset 16 :size 1) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype dma-sqwc (uint32) + ((sqwc uint8 :offset 0 :size 8) + (tqwc uint8 :offset 16 :size 8) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype dma-bank-control (structure) + ((ctrl dma-ctrl :offset 0) + (stat uint32 :offset 16) + (pcr uint32 :offset 32) + (sqwc dma-sqwc :offset 48) + (rbsr uint32 :offset 64) + (rbor uint32 :offset 80) + (stadr uint32 :offset 96) + (enabler uint32 :offset 5408) + (enablew uint32 :offset 5520) + ) + :method-count-assert 9 + :size-assert #x1594 + :flag-assert #x900001594 + ) + +(deftype vu-code-block (basic) + ((name basic :offset-assert 4) + (code uint32 :offset-assert 8) + (size int32 :offset-assert 12) + (dest-address uint32 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + ) + +(deftype vu-stat (uint64) + () + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(defenum dma-tag-id + :bitfield #f + :type uint8 + (refe 0) ;; addr=ADDR, ends after this transfer + (cnt 1) ;; addr=after tag, next-tag=after data + (next 2) ;; addr=after tag, next-tag=ADDR + (ref 3) ;; addr=ADDR, next-tag=after tag + (refs 4) ;; ref, but stall controled + (call 5) ;; + (ret 6) ;; + (end 7) ;; next, but ends. + ) + +(deftype dma-tag (uint64) + ((qwc uint16 :offset 0 :size 16) + (pce uint8 :offset 26 :size 2) + (id dma-tag-id :offset 28 :size 3) + (irq uint8 :offset 31 :size 1) + (addr uint32 :offset 32 :size 31) + (spr uint8 :offset 63 :size 1) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype dma-bucket (structure) + ((tag dma-tag :offset-assert 0) + (last (pointer dma-tag) :offset-assert 8) + (dummy uint32 :offset-assert 12) + (next uint32 :offset 4) + (clear uint64 :offset 8) + (vif0 uint32 :offset 8) + (vif1 uint32 :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype vif-mask (uint32) + ((m0 uint8 :offset 0 :size 2) + (m1 uint8 :offset 2 :size 2) + (m2 uint8 :offset 4 :size 2) + (m3 uint8 :offset 6 :size 2) + (m4 uint8 :offset 8 :size 2) + (m5 uint8 :offset 10 :size 2) + (m6 uint8 :offset 12 :size 2) + (m7 uint8 :offset 14 :size 2) + (m8 uint8 :offset 16 :size 2) + (m9 uint8 :offset 18 :size 2) + (m10 uint8 :offset 20 :size 2) + (m11 uint8 :offset 22 :size 2) + (m12 uint8 :offset 24 :size 2) + (m13 uint8 :offset 26 :size 2) + (m14 uint8 :offset 28 :size 2) + (m15 uint8 :offset 30 :size 2) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype vif-stcycl-imm (uint16) + ((cl uint8 :offset 0 :size 8) + (wl uint8 :offset 8 :size 8) + ) + :method-count-assert 9 + :size-assert #x2 + :flag-assert #x900000002 + ) + +(deftype vif-unpack-imm (uint16) + ((addr uint16 :offset 0 :size 10) + (usn uint8 :offset 14 :size 1) + (flg uint8 :offset 15 :size 1) + ) + :method-count-assert 9 + :size-assert #x2 + :flag-assert #x900000002 + ) + + +;; all these have mask (only applies to unpacks) and interrupt not set. +(defenum vif-cmd + :bitfield #f + :type uint8 + (nop 0) ;; no-op, can still have irq set. + (stcycl 1) ;; set write recycle register + (offset 2) ;; set offset register + (base 3) ;; set base register + (itop 4) ;; set data pointer register (itops) + (stmod 5) ;; set mode register + (mskpath3 6) ;; set path 3 mask + (mark 7) ;; set mark register + (pc-port 8) ;; special tag for PC Port data. + (flushe 16) ;; wait for end of microprogram + (flush 17) ;; wait for end of microprogram and transfer (path1/path2) + (flusha 19) ;; wait for end of microprogram and transfer (path1/path2/path3) + (mscal 20) ;; activate microprogram (call) + (mscalf 21) ;; flushe and activate (call) + (mscnt 23) ;; activate microprogram (continue) + (stmask 32) ;; set MASK register. + (strow 48) ;; set filling data + (stcol 49) ;; set filling data + (mpg 74) ;; transfer microprogram + (direct 80) ;; straight to GIF. + (directhl 81) + (unpack-s-32 96) + (unpack-s-16 97) + (unpack-s-8 98) + ;; 99 is invllid + (unpack-v2-32 100) + (unpack-v2-16 101) + (unpack-v2-8 102) + ;; 103 is invalid + (unpack-v3-32 104) + (unpack-v3-16 105) + (unpack-v3-8 106) + ;; 107 is invalid + (unpack-v4-32 108) + (unpack-v4-16 109) + (unpack-v4-8 110) + (unpack-v4-5 111) + (cmd-mask 239) ;; not sure what this is. + ) + +;; this makes a copy of the above type, but uses a uint32. +(defenum vif-cmd-32 + :bitfield #f + :type uint32 + :copy-entries vif-cmd + ) + +(deftype vif-tag (uint32) + ((imm uint16 :offset 0 :size 16) + (num uint8 :offset 16 :size 8) + (cmd vif-cmd :offset 24 :size 7) + (irq uint8 :offset 31 :size 1) + (msk uint8 :offset 28 :size 1) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + + +;; dma-sync-fast +;; dma-send-no-scratch +;; dma-sync-with-count +;; dma-count-until-done diff --git a/goal_src/jak2/engine/dma/dma.gc b/goal_src/jak2/engine/dma/dma.gc index e6b40392bb..27064cb040 100644 --- a/goal_src/jak2/engine/dma/dma.gc +++ b/goal_src/jak2/engine/dma/dma.gc @@ -5,3 +5,17 @@ ;; name in dgo: dma ;; dgos: ENGINE, GAME +(defun ultimate-memcpy ((dst pointer) (src pointer) (size-bytes uint)) + ;; on PC Port, just call C mem-move, it's the fastest. + (__mem-move dst src size-bytes) + ) + +(defun dma-send ((arg0 dma-bank) (madr uint) (qwc uint)) + (format 0 "dma-send~%") + (break!) + ) + +(defun dma-send-chain ((arg0 dma-bank-source) (tadr uint)) + (format 0 "dma-send-chain~%") + (break!) + ) \ No newline at end of file diff --git a/goal_src/jak2/engine/game/main-h.gc b/goal_src/jak2/engine/game/main-h.gc index 822df2ff04..127e8d8061 100644 --- a/goal_src/jak2/engine/game/main-h.gc +++ b/goal_src/jak2/engine/game/main-h.gc @@ -1,7 +1,196 @@ ;;-*-Lisp-*- (in-package goal) - -;; name: main-h.gc ;; name in dgo: main-h ;; dgos: ENGINE, GAME +(declare-type debug-menu-context basic) + +(define *stats-poly* #f) +(define *stats-memory* #f) +(define *stats-memory-short* #f) +(define *stats-memory-level-index* 0) +(define *stats-collide* #f) +(define *stats-bsp* #f) +(define *stats-buffer* #f) +(define *stats-target* #f) +(define *stats-profile-bars* #f) +(define *stats-perf* #f) +(define *artist-all-visible* #f) +(define *artist-flip-visible* #f) +(define *artist-fix-visible* #f) +(define *artist-fix-frustum* #f) +(define *artist-error-spheres* #f) +(define *artist-use-menu-subdiv* #f) +(define *display-profile* #t) +(define *display-sidekick-stats* #f) +(define *display-quad-stats* #f) +(define *display-tri-stats* #f) +(define *display-ground-stats* #f) +(define *display-collision-marks* #f) +(define *display-collide-cache* #f) +(define *display-render-collision* #f) +(define *display-hipri-collision-marks* #f) +(define *display-edge-collision-marks* #f) +(define *display-geo-marks* #f) +(define *display-target-marks* #f) +(define *target-rc-board-controls* #f) +(define *display-collide-history* 0) +(define *display-xyz-axes* #f) +(define *display-cam-collide-history* #f) +(define *record-cam-collide-history* #f) +(define *display-cam-master-marks* #f) +(define *display-cam-other* #f) +(define *display-camera-marks* #f) +(define *camera-no-mip-correction* #f) +(define *display-cam-los-info* #f) +(define *display-cam-los-debug* #f) +(define *display-cam-los-marks* #f) +(define *display-cam-coll-marks* #f) +(define *display-camera-info* #f) +(define *display-camera-old-stats* #f) +(define *display-camera-last-attacker* #f) +(define *display-file-info* #f) +(define *display-actor-marks* #f) +(define *display-sprite-info* #f) +(define *display-sprite-marks* #f) +(define *display-sprite-spheres* #f) +(define *display-entity-errors* #t) +(define *display-instance-info* #f) +(define *display-deci-count* #f) +(define *sync-dma* #f) +(define *display-strip-lines* 0) +(define *display-battle-marks* #f) +(define *display-joint-axes* #f) +(define *display-nav-marks* #f) +(define *display-nav-network* #f) +(define *display-path-marks* #f) +(define *display-vol-marks* #f) +(define *display-water-marks* #f) +(define *display-nav-mesh* #f) +(define *display-actor-pointer* #f) +(define *display-actor-vis* #f) +(define *display-actor-graph* #f) +(define *display-traffic-height-map* #f) +(define *display-trail-graph* #f) +(define *display-color-bars* #f) +(define *display-bug-report* #f) +(define *display-level-border* #f) +(define *display-memcard-info* #f) +(define *display-split-boxes* #f) +(define *display-split-box-info* #f) +(define *display-texture-distances* #f) +(define *display-texture-download* #f) +(define *display-art-control* #f) +(define *display-gui-control* #f) +(define *display-level-spheres* #f) +(define *time-of-day-fast* #f) +(define *display-iop-info* #f) +(define *ambient-sound-class* #t) +(define *slow-frame-rate* #f) +(define *display-region-marks* #f) +(define *execute-regions* #t) +(define *debug-pause* #f) +(define *debug-view-anims* #f) +(define *debug-unkillable* #f) +(define *debug-actor* (the-as object #f)) +(define *gun-marks* #f) +(define *bug-report-output-mode* (if *debug-segment* + 'file-stream + '*stdcon* + ) + ) +(define *display-scene-control* 0) +(define *display-bot-marks* 0) +(define *display-race-marks* 0) +(define *race-record-path* #f) +(define *select-race* 0) +(define *select-race-path* 0) +(define *bot-record-path* -1) +(define *subdivide-draw-mode* 0) +(define *subdivide-scissor-draw-mode* 0) +(define *subdivide-foreground-draw-mode* 0) +(define *subdivide-ocean-draw-mode* 0) +(define *ocean-height-hack* 0) +(define-perm *dproc* process #f) +(define *run* #f) +(define *teleport* #f) +(define *teleport-count* 0) +(define *draw-hook* (the-as (function none) nothing)) +(define *debug-hook* '()) +(define *menu-hook* (the-as (function debug-menu-context) nothing)) +(define *progress-hook* nothing) +(define *dma-timeout-hook* nothing) + +(deftype frame-stats (structure) + ((field-time time-frame 2 :offset-assert 0) + (field int32 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + ) + +(define *frame-stats* (new 'static 'frame-stats)) + +(deftype screen-filter (basic) + ((draw? basic :offset-assert 4) + (bucket int32 :offset-assert 8) + (color vector :inline :offset-assert 16) + (color-src vector :inline :offset-assert 32) + (color-dest vector :inline :offset-assert 48) + (extra vector :inline :offset-assert 64) + (speed float :offset 64) + (current-interp float :offset 68) + ) + :method-count-assert 12 + :size-assert #x50 + :flag-assert #xc00000050 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + ) + ) + +(deftype col-rend (basic) + ((draw? symbol :offset-assert 4) + (outline? symbol :offset-assert 8) + (show-back-faces? symbol :offset-assert 12) + (show-normals? symbol :offset-assert 16) + (ghost-hidden? symbol :offset-assert 20) + (show-only uint32 :offset-assert 24) + (cspec uint32 :offset-assert 28) + (track uint8 :offset-assert 32) + (bbox-radius float :offset-assert 36) + (bbox-center vector :inline :offset-assert 48) + (camera-to-bbox-dist float :offset-assert 64) + ) + :method-count-assert 10 + :size-assert #x44 + :flag-assert #xa00000044 + (:methods + (dummy-9 () none 9) + ) + ) + +(define *col-rend* (new 'static 'col-rend + :draw? #f + :outline? #t + :show-back-faces? #t + :show-normals? #f + :ghost-hidden? #t + :cspec #x38 + :track #x1 + :bbox-radius 24576.0 + :camera-to-bbox-dist 65536.0 + ) + + ) +(defun-debug debug-actor? ((arg0 object)) + (= arg0 *debug-actor*) + ) +0 + + + + diff --git a/goal_src/jak2/engine/geometry/geometry-h.gc b/goal_src/jak2/engine/geometry/geometry-h.gc index cee396e514..b6149ca3c7 100644 --- a/goal_src/jak2/engine/geometry/geometry-h.gc +++ b/goal_src/jak2/engine/geometry/geometry-h.gc @@ -32,3 +32,5 @@ (point-past-plane? (_type_ vector) symbol 10) ) ) + +(define-extern quaternion-from-two-vectors-max-angle! (function quaternion vector vector float quaternion)) diff --git a/goal_src/jak2/engine/geometry/geometry.gc b/goal_src/jak2/engine/geometry/geometry.gc index f7d8972d51..147df0bce7 100644 --- a/goal_src/jak2/engine/geometry/geometry.gc +++ b/goal_src/jak2/engine/geometry/geometry.gc @@ -5,3 +5,1472 @@ ;; name in dgo: geometry ;; dgos: ENGINE, GAME +(defun vector-flatten! ((arg0 vector) (arg1 vector) (arg2 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.mov.vf vf3 vf0 :mask #b1000) + (.outer.product.a.vf acc vf1 vf2) + (.outer.product.b.vf vf3 vf2 vf1 acc) + (.outer.product.a.vf acc vf2 vf3) + (.outer.product.b.vf vf3 vf3 vf2 acc) + (.svf (&-> arg0 quad) vf3) + arg0 + ) + ) + +(defun vector-reflect! ((arg0 vector) (arg1 vector) (arg2 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.mov.vf vf3 vf0 :mask #b1000) + (.outer.product.a.vf acc vf1 vf2) + (.outer.product.b.vf vf3 vf2 vf1 acc) + (.outer.product.a.vf acc vf2 vf3) + (.outer.product.b.vf vf3 vf3 vf2 acc) + (.add.vf acc vf3 vf3 :mask #b111) + (.sub.mul.w.vf vf3 vf1 vf0 acc :mask #b111) + (.svf (&-> arg0 quad) vf3) + arg0 + ) + ) + +(defun vector-reflect-flat! ((arg0 vector) (arg1 vector) (arg2 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.mov.vf vf3 vf0 :mask #b1000) + (.outer.product.a.vf acc vf1 vf2) + (.outer.product.b.vf vf3 vf2 vf1 acc) + (.outer.product.a.vf acc vf2 vf3) + (.outer.product.b.vf vf3 vf3 vf2 acc) + (.add.vf vf3 vf3 vf2 :mask #b111) + (.svf (&-> arg0 quad) vf3) + arg0 + ) + ) + +(defun vector-reflect-flat-above! ((arg0 vector) (arg1 vector) (arg2 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.mov.vf vf3 vf0 :mask #b1000) + (.outer.product.a.vf acc vf1 vf2) + (.outer.product.b.vf vf3 vf2 vf1 acc) + (.outer.product.a.vf acc vf2 vf3) + (.outer.product.b.vf vf3 vf3 vf2 acc) + (.svf (&-> arg0 quad) vf3) + (let* ((f0-0 (vector-length arg0)) + (f1-1 (vector-dot arg0 arg2)) + (f0-2 (- (* 0.02 f0-0) f1-1)) + ) + (vector+float*! arg0 arg0 arg2 (fmin 16384.0 (* 16.0 f0-2))) + ) + ) + ) + +(defun vector-reflect-flat-gravity! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector)) + (let ((s4-0 (new 'stack-no-clear 'vector))) + (set! (-> s4-0 quad) (-> arg1 quad)) + (vector-reflect-flat! arg0 s4-0 arg2) + (let* ((s2-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) s4-0 1.0)) + (f28-0 (vector-length s4-0)) + (f30-0 (vector-length arg0)) + (f0-1 (vector-dot s2-0 arg2)) + (f1-1 (vector-dot arg3 arg2)) + ) + (when (and (< 0.0001 f1-1) (< 8192.0 f28-0)) + (let ((f0-3 (- (/ f0-1 f1-1)))) + (vector+float*! arg0 s4-0 arg3 (* f28-0 f0-3)) + ) + (vector+! arg0 arg0 arg2) + (vector-normalize! arg0 f30-0) + ) + ) + ) + arg0 + ) + +(defun vector-segment-distance-point! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector)) + "Compute the distance from a point to the closest point on the line segment. + arg0 is the point. arg1/arg2 are the endpoints of the line segment. + arg3 is an optional output closest point." + (local-vars (v0-0 float) (v1-0 float) (v1-1 float)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + (vf8 :class vf) + ) + (init-vf0-vector) + (nop!) + (.lvf vf3 (&-> arg1 quad)) + (.lvf vf4 (&-> arg2 quad)) + (.lvf vf5 (&-> arg0 quad)) + (.sub.vf vf1 vf4 vf3) + (.sub.vf vf6 vf5 vf3) + (.mul.vf vf2 vf1 vf1) + (.mul.x.vf acc vf0 vf2 :mask #b1000) + (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000) + (.add.mul.z.vf vf2 vf0 vf2 acc :mask #b1000) + (.sqrt.vf Q vf2 :ftf #b11) + (.wait.vf) + (.add.vf vf2 vf0 Q :mask #b1) + (.nop.vf) + (.nop.vf) + (.div.vf Q vf0 vf2 :fsf #b11 :ftf #b0) + (.mov v1-0 vf2) + (let ((f2-0 v1-0)) + (.wait.vf) + (.mul.vf vf1 vf1 Q) + (.mul.vf vf7 vf1 vf6) + (let ((f1-0 0.0)) + (.add.y.vf vf7 vf7 vf7 :mask #b1) + (.add.z.vf vf7 vf7 vf7 :mask #b1) + (.mov v1-1 vf7) + (let ((f0-0 v1-1)) + (b! (< f0-0 f1-0) cfg-4 :likely-delay (set! f0-0 f1-0)) + (b! (< f2-0 f0-0) cfg-4 :likely-delay (set! f0-0 f2-0)) + (label cfg-4) + (let ((v1-2 f0-0)) + (.mov vf7 v1-2) + ) + ) + ) + ) + (.mul.x.vf vf1 vf1 vf7) + (b! (= arg3 #f) cfg-6 :delay (.mov.vf vf8 vf0 :mask #b1000)) + (.add.vf vf8 vf3 vf1 :mask #b111) + (.svf (&-> arg3 quad) vf8) + (label cfg-6) + (.sub.vf vf2 vf6 vf1) + (.mul.vf vf2 vf2 vf2) + (.mul.x.vf acc vf0 vf2 :mask #b1000) + (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000) + (.add.mul.z.vf vf2 vf0 vf2 acc :mask #b1000) + (.sqrt.vf Q vf2 :ftf #b11) + (.wait.vf) + (.add.vf vf2 vf0 Q :mask #b1) + (.nop.vf) + (.mov v0-0 vf2) + v0-0 + ) + ) + +(defun vector-line-distance ((arg0 vector) (arg1 vector) (arg2 vector)) + (let* ((a1-3 (vector-normalize! (vector-! (new-stack-vector0) arg2 arg1) 1.0)) + (gp-1 (vector-! (new-stack-vector0) arg0 arg1)) + (f0-1 (vector-dot a1-3 gp-1)) + (v1-3 (vector-float*! (new-stack-vector0) a1-3 f0-1)) + ) + (vector-length (vector-! (new-stack-vector0) gp-1 v1-3)) + ) + ) + +(defun vector-line-distance-point! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector)) + (let* ((a1-3 (vector-normalize! (vector-! (new-stack-vector0) arg2 arg1) 1.0)) + (s4-1 (vector-! (new-stack-vector0) arg0 arg1)) + (f0-1 (vector-dot a1-3 s4-1)) + (v1-4 (vector-float*! (new-stack-vector0) a1-3 f0-1)) + ) + (if arg3 + (vector+! arg3 arg1 v1-4) + ) + (vector-length (vector-! (new-stack-vector0) s4-1 v1-4)) + ) + ) + +(defun vector-segment-overlap ((arg0 vector) (arg1 vector) (arg2 vector)) + (let* ((gp-1 (vector-! (new 'stack-no-clear 'vector) arg1 arg2)) + (s5-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) gp-1 1.0)) + ) + (let ((a3-0 (new 'stack-no-clear 'vector))) + (vector-line-distance-point! arg0 arg1 arg2 a3-0) + ) + (/ (vector-dot s5-0 (vector-! (new 'stack-no-clear 'vector) arg1 arg0)) (vector-length gp-1)) + ) + ) + +(defun line-sphere-intersection? ((arg0 vector) (arg1 vector) (arg2 vector)) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (let ((s3-0 (new 'stack-no-clear 'vector)) + (f30-0 0.0) + ) + (vector-! s3-0 arg2 arg1) + (let ((f0-0 (vector-length-squared s3-0))) + (if (< 0.0 f0-0) + (set! f30-0 (/ 1.0 f0-0)) + ) + ) + (let ((v1-6 (new 'stack-no-clear 'vector))) + (vector-! v1-6 arg0 arg1) + (let* ((f1-2 (* (vector-dot s3-0 v1-6) f30-0)) + (f0-5 (fmax 0.0 (fmin 1.0 f1-2))) + ) + (vector+float*! s5-0 arg1 s3-0 f0-5) + ) + ) + ) + (let ((f0-6 (vector-vector-distance-squared s5-0 arg0)) + (f1-4 (-> arg0 w)) + ) + (< f0-6 (* f1-4 f1-4)) + ) + ) + ) + +(defun vector-orient-by-quat! ((arg0 vector) (arg1 vector) (arg2 quaternion)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg2 vec quad)) + (.lvf vf6 (&-> arg1 quad)) + (.add.vf vf5 vf1 vf1) + (.add.w.vf vf2 vf0 vf1 :mask #b1) + (.add.z.vf vf2 vf0 vf1 :mask #b10) + (.sub.y.vf vf2 vf0 vf1 :mask #b100) + (.sub.w.vf vf2 vf0 vf0 :mask #b1000) + (.sub.z.vf vf3 vf0 vf1 :mask #b1) + (.add.w.vf vf3 vf0 vf1 :mask #b10) + (.add.x.vf vf3 vf0 vf1 :mask #b100) + (.sub.w.vf vf3 vf0 vf0 :mask #b1000) + (.add.y.vf vf4 vf0 vf1 :mask #b1) + (.sub.x.vf vf4 vf0 vf1 :mask #b10) + (.add.w.vf vf4 vf0 vf1 :mask #b100) + (.sub.w.vf vf4 vf0 vf0 :mask #b1000) + (.outer.product.a.vf acc vf5 vf2) + (.outer.product.b.vf vf2 vf2 vf5 acc) + (.outer.product.a.vf acc vf5 vf3) + (.outer.product.b.vf vf3 vf3 vf5 acc) + (.outer.product.a.vf acc vf5 vf4) + (.outer.product.b.vf vf4 vf4 vf5 acc) + (.add.w.vf vf2 vf2 vf0 :mask #b1) + (.add.w.vf vf3 vf3 vf0 :mask #b10) + (.add.w.vf vf4 vf4 vf0 :mask #b100) + (.mul.w.vf acc vf0 vf6) + (.add.mul.x.vf acc vf2 vf6 acc) + (.add.mul.y.vf acc vf3 vf6 acc) + (.add.mul.z.vf vf6 vf4 vf6 acc) + (.svf (&-> arg0 quad) vf6) + arg0 + ) + ) + +(defun vector-inv-orient-by-quat! ((arg0 vector) (arg1 vector) (arg2 quaternion)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (init-vf0-vector) + ;; (.sub.vf vf7 vf7 vf7) + (.xor.vf vf7 vf7 vf7) + (.lvf vf1 (&-> arg2 vec quad)) + (.lvf vf6 (&-> arg1 quad)) + (.sub.vf vf1 vf7 vf1 :mask #b111) + (.add.vf vf5 vf1 vf1) + (.add.w.vf vf2 vf0 vf1 :mask #b1) + (.add.z.vf vf2 vf0 vf1 :mask #b10) + (.sub.y.vf vf2 vf0 vf1 :mask #b100) + (.sub.w.vf vf2 vf0 vf0 :mask #b1000) + (.sub.z.vf vf3 vf0 vf1 :mask #b1) + (.add.w.vf vf3 vf0 vf1 :mask #b10) + (.add.x.vf vf3 vf0 vf1 :mask #b100) + (.sub.w.vf vf3 vf0 vf0 :mask #b1000) + (.add.y.vf vf4 vf0 vf1 :mask #b1) + (.sub.x.vf vf4 vf0 vf1 :mask #b10) + (.add.w.vf vf4 vf0 vf1 :mask #b100) + (.sub.w.vf vf4 vf0 vf0 :mask #b1000) + (.outer.product.a.vf acc vf5 vf2) + (.outer.product.b.vf vf2 vf2 vf5 acc) + (.outer.product.a.vf acc vf5 vf3) + (.outer.product.b.vf vf3 vf3 vf5 acc) + (.outer.product.a.vf acc vf5 vf4) + (.outer.product.b.vf vf4 vf4 vf5 acc) + (.add.w.vf vf2 vf2 vf0 :mask #b1) + (.add.w.vf vf3 vf3 vf0 :mask #b10) + (.add.w.vf vf4 vf4 vf0 :mask #b100) + (.mul.w.vf acc vf0 vf6) + (.add.mul.x.vf acc vf2 vf6 acc) + (.add.mul.y.vf acc vf3 vf6 acc) + (.add.mul.z.vf vf6 vf4 vf6 acc) + (.svf (&-> arg0 quad) vf6) + arg0 + ) + ) + +(defun forward-down->inv-matrix ((arg0 matrix) (arg1 vector) (arg2 vector)) + (vector-normalize-copy! (the-as vector (&-> arg0 data 8)) arg1 1.0) + (vector-cross! (the-as vector (-> arg0 data)) (the-as vector (&-> arg0 data 8)) arg2) + (vector-normalize! (the-as vector (-> arg0 data)) 1.0) + (vector-cross! (the-as vector (&-> arg0 data 4)) arg1 (the-as vector (-> arg0 data))) + (vector-normalize! (the-as vector (&-> arg0 data 4)) 1.0) + (set! (-> arg0 trans quad) (the-as uint128 0)) + (set! (-> arg0 data 3) 0.0) + (set! (-> arg0 data 7) 0.0) + (set! (-> arg0 data 11) 0.0) + (set! (-> arg0 trans w) 1.0) + arg0 + ) + +(defun forward-down-nopitch->inv-matrix ((arg0 matrix) (arg1 vector) (arg2 vector)) + (vector-normalize-copy! (the-as vector (&-> arg0 data 4)) arg2 1.0) + (vector-negate! (the-as vector (&-> arg0 data 4)) (the-as vector (&-> arg0 data 4))) + (vector-cross! (the-as vector (-> arg0 data)) (the-as vector (&-> arg0 data 4)) arg1) + (vector-normalize! (the-as vector (-> arg0 data)) 1.0) + (vector-cross! + (the-as vector (&-> arg0 data 8)) + (the-as vector (-> arg0 data)) + (the-as vector (&-> arg0 data 4)) + ) + (vector-normalize! (the-as vector (&-> arg0 data 8)) 1.0) + (set! (-> arg0 trans quad) (the-as uint128 0)) + (set! (-> arg0 data 3) 0.0) + (set! (-> arg0 data 7) 0.0) + (set! (-> arg0 data 11) 0.0) + (set! (-> arg0 trans w) 1.0) + arg0 + ) + +(defun forward-up->inv-matrix ((arg0 matrix) (arg1 vector) (arg2 vector)) + (forward-down->inv-matrix arg0 arg1 (vector-negate! (new 'stack-no-clear 'vector) arg2)) + ) + +(defun forward-up-nopitch->inv-matrix ((arg0 matrix) (arg1 vector) (arg2 vector)) + (forward-down-nopitch->inv-matrix arg0 arg1 (vector-negate! (new-stack-vector0) arg2)) + ) + +(defun forward-up-nopitch->quaternion ((arg0 quaternion) (arg1 vector) (arg2 vector)) + (matrix->quaternion arg0 (forward-up-nopitch->inv-matrix (new-stack-matrix0) arg1 arg2)) + ) + +(defun forward-up->quaternion ((arg0 quaternion) (arg1 vector) (arg2 vector)) + (matrix->quaternion + arg0 + (forward-down->inv-matrix (new-stack-matrix0) arg1 (vector-negate! (new 'stack-no-clear 'vector) arg2)) + ) + ) + +(defun quaternion-from-two-vectors! ((arg0 quaternion) (arg1 vector) (arg2 vector)) + (let* ((s5-0 (vector-cross! (new-stack-vector0) arg1 arg2)) + (f1-0 (vector-length s5-0)) + (f0-1 (vector-dot arg1 arg2)) + ) + (let ((f1-1 (/ (sqrtf (* 0.5 (- 1.0 f0-1))) f1-0))) + (set! (-> arg0 x) (* (-> s5-0 x) f1-1)) + (set! (-> arg0 y) (* (-> s5-0 y) f1-1)) + (set! (-> arg0 z) (* (-> s5-0 z) f1-1)) + ) + (set! (-> arg0 w) (sqrtf (* 0.5 (+ 1.0 f0-1)))) + ) + arg0 + ) + +(defun quaternion-from-two-vectors-partial! ((arg0 quaternion) (arg1 vector) (arg2 vector) (arg3 float)) + (let* ((s5-0 (vector-cross! (new-stack-vector0) arg1 arg2)) + (f0-0 (vector-length s5-0)) + (f1-1 (+ 1.0 (* arg3 (+ -1.0 (vector-dot arg1 arg2))))) + ) + (let ((f0-1 (/ (sqrtf (* 0.5 (- 1.0 f1-1))) f0-0))) + (set! (-> arg0 x) (* (-> s5-0 x) f0-1)) + (set! (-> arg0 y) (* (-> s5-0 y) f0-1)) + (set! (-> arg0 z) (* (-> s5-0 z) f0-1)) + ) + (set! (-> arg0 w) (sqrtf (* 0.5 (+ 1.0 f1-1)))) + ) + arg0 + ) + +(defun quaternion-from-two-vectors-max-angle! ((arg0 quaternion) (arg1 vector) (arg2 vector) (arg3 float)) + (let* ((s5-0 (vector-cross! (new-stack-vector0) arg1 arg2)) + (f30-0 (vector-length s5-0)) + (f26-0 (vector-dot arg1 arg2)) + (f28-0 (sqrtf (* 0.5 (- 1.0 f26-0)))) + ) + (let ((f0-5 (sin (* 0.5 arg3)))) + (cond + ((< f0-5 f28-0) + (set! f28-0 f0-5) + (set! (-> arg0 w) (cos (* 0.5 arg3))) + ) + (else + (set! (-> arg0 w) (sqrtf (* 0.5 (+ 1.0 f26-0)))) + ) + ) + ) + (let ((f0-12 (/ f28-0 f30-0))) + (set! (-> arg0 x) (* (-> s5-0 x) f0-12)) + (set! (-> arg0 y) (* (-> s5-0 y) f0-12)) + (set! (-> arg0 z) (* (-> s5-0 z) f0-12)) + ) + ) + arg0 + ) + +(defun quaternion-from-two-vectors-max-angle-partial! ((arg0 quaternion) (arg1 vector) (arg2 vector) (arg3 float) (arg4 float)) + (let* ((s5-0 (vector-cross! (new-stack-vector0) arg1 arg2)) + (f30-0 (vector-length s5-0)) + (f26-0 (+ 1.0 (* arg4 (+ -1.0 (vector-dot arg1 arg2))))) + (f28-0 (sqrtf (* 0.5 (- 1.0 f26-0)))) + ) + (let ((f0-5 (sin (* 0.5 arg3)))) + (cond + ((< f0-5 f28-0) + (set! f28-0 f0-5) + (set! (-> arg0 w) (cos (* 0.5 arg3))) + ) + (else + (set! (-> arg0 w) (sqrtf (* 0.5 (+ 1.0 f26-0)))) + ) + ) + ) + (let ((f0-12 (/ f28-0 f30-0))) + (set! (-> arg0 x) (* (-> s5-0 x) f0-12)) + (set! (-> arg0 y) (* (-> s5-0 y) f0-12)) + (set! (-> arg0 z) (* (-> s5-0 z) f0-12)) + ) + ) + arg0 + ) + +(defun matrix-from-two-vectors! ((arg0 matrix) (arg1 vector) (arg2 vector)) + (let* ((a1-3 (vector-normalize! (vector-cross! (new-stack-vector0) arg2 arg1) 1.0)) + (f0-1 (vector-dot arg1 arg2)) + (f1-0 1.0) + (f2-0 f0-1) + (f1-2 (sqrtf (- f1-0 (* f2-0 f2-0)))) + ) + (matrix-axis-sin-cos! arg0 a1-3 f1-2 f0-1) + ) + ) + +(defun matrix-from-two-vectors-max-angle! ((arg0 matrix) (arg1 vector) (arg2 vector) (arg3 float)) + (let ((s4-1 (vector-normalize! (vector-cross! (new-stack-vector0) arg2 arg1) 1.0)) + (f30-0 (vector-dot arg1 arg2)) + (f28-0 (cos arg3)) + ) + (cond + ((< f30-0 f28-0) + (matrix-axis-sin-cos! arg0 s4-1 (sin arg3) f28-0) + ) + (else + (let ((t9-5 matrix-axis-sin-cos!) + (a0-6 arg0) + (a1-4 s4-1) + (f0-1 1.0) + (f1-0 f30-0) + ) + (t9-5 a0-6 a1-4 (sqrtf (- f0-1 (* f1-0 f1-0))) f30-0) + ) + ) + ) + ) + ) + +(defun matrix-from-two-vectors-smooth! ((arg0 matrix) (arg1 vector) (arg2 vector) (arg3 float) (arg4 int)) + (with-pp + (let* ((s5-1 (vector-normalize! (vector-cross! (new 'stack-no-clear 'vector) arg2 arg1) 1.0)) + (f0-1 (vector-dot arg1 arg2)) + (f0-2 (acos f0-1)) + (f1-2 (fmin (* arg3 (-> pp clock seconds-per-frame)) (/ (* 5.0 (fabs f0-2)) (the float arg4)))) + (f30-0 (fmax (fmin f0-2 f1-2) (- f1-2))) + ) + (matrix-axis-sin-cos! arg0 s5-1 (sin f30-0) (cos f30-0)) + ) + arg0 + ) + ) + +(defun matrix-from-two-vectors-the-long-way-smooth! ((arg0 matrix) (arg1 vector) (arg2 vector) (arg3 float) (arg4 int)) + (with-pp + (let* ((s5-1 (vector-normalize! (vector-cross! (new 'stack-no-clear 'vector) arg2 arg1) 1.0)) + (f0-1 (vector-dot arg1 arg2)) + (f0-3 (- (acos f0-1))) + (f1-2 (fmin (* arg3 (-> pp clock seconds-per-frame)) (/ (* 5.0 (fabs f0-3)) (the float arg4)))) + (f30-0 (fmax (fmin f0-3 f1-2) (- f1-2))) + ) + (matrix-axis-sin-cos! arg0 s5-1 (sin f30-0) (cos f30-0)) + ) + arg0 + ) + ) + +(defun quaternion-from-two-vectors-smooth! ((arg0 quaternion) (arg1 vector) (arg2 vector) (arg3 float) (arg4 int)) + (let ((a1-1 (matrix-from-two-vectors-smooth! (new 'stack-no-clear 'matrix) arg1 arg2 arg3 arg4))) + (matrix->quaternion arg0 a1-1) + ) + ) + +(defun matrix-from-two-vectors-max-angle-partial! ((arg0 matrix) (arg1 vector) (arg2 vector) (arg3 float) (arg4 float)) + (let* ((s4-1 (vector-normalize! (vector-cross! (new 'stack-no-clear 'vector) arg2 arg1) 1.0)) + (f28-0 (vector-dot arg1 arg2)) + (f30-0 (cos arg3)) + (f0-2 (+ 1.0 (* (+ -1.0 f28-0) arg4))) + ) + (cond + ((< f0-2 f30-0) + (matrix-axis-sin-cos! arg0 s4-1 (sin arg3) f30-0) + ) + (else + (let ((t9-5 matrix-axis-sin-cos!) + (a0-6 arg0) + (a1-4 s4-1) + (f1-3 1.0) + (f2-1 f0-2) + ) + (t9-5 a0-6 a1-4 (sqrtf (- f1-3 (* f2-1 f2-1))) f0-2) + ) + ) + ) + ) + ) + +(defun matrix-from-two-vectors-partial-linear! ((arg0 matrix) (arg1 vector) (arg2 vector) (arg3 float)) + (let ((gp-1 (vector-normalize! (vector-cross! (new-stack-vector0) arg2 arg1) 1.0)) + (f0-1 (vector-dot arg1 arg2)) + ) + (cond + ((< 0.9999 (fabs f0-1)) + (matrix-identity! arg0) + ) + (else + (let* ((f0-4 (cos (* arg3 (acos f0-1)))) + (t9-5 matrix-axis-sin-cos!) + (a0-6 arg0) + (f1-1 1.0) + (f2-1 f0-4) + ) + (t9-5 a0-6 gp-1 (sqrtf (- f1-1 (* f2-1 f2-1))) f0-4) + ) + ) + ) + ) + ) + +(defun matrix-remove-z-rot ((arg0 matrix) (arg1 matrix)) + (let ((s4-0 (new-stack-vector0))) + 0.0 + 0.0 + (let ((s5-0 (new-stack-matrix0))) + (vector-negate! s4-0 (the-as vector arg1)) + (vector-flatten! s4-0 s4-0 (the-as vector (&-> arg0 data 8))) + (vector-normalize! s4-0 1.0) + (let ((f30-0 (vector-dot (the-as vector (&-> arg0 data 4)) s4-0))) + (when (< f30-0 0.99999) + (vector-cross! s4-0 (the-as vector (&-> arg0 data 4)) s4-0) + (let ((f0-4 (vector-length s4-0))) + (if (< 0.0 (vector-dot s4-0 (the-as vector (&-> arg0 data 8)))) + (set! f0-4 (- f0-4)) + ) + (matrix-axis-sin-cos! s5-0 (the-as vector (&-> arg0 data 8)) f0-4 f30-0) + ) + (matrix*! arg0 arg0 s5-0) + ) + ) + ) + ) + arg0 + ) + +(defun matrix-rot-diff! ((arg0 vector) (arg1 matrix) (arg2 matrix)) + (let ((s3-0 (new-stack-quaternion0)) + (s2-0 (new-stack-quaternion0)) + (s5-0 (new-stack-quaternion0)) + ) + 0.0 + (matrix->quaternion s3-0 arg1) + (matrix->quaternion s2-0 arg2) + (quaternion-conjugate! s5-0 s3-0) + (quaternion*! s5-0 s2-0 s5-0) + (quaternion-normalize! s5-0) + (if (< (-> s5-0 w) 0.0) + (quaternion-negate! s5-0 s5-0) + ) + (let ((f30-1 (* 2.0 (acos (-> s5-0 w))))) + (set! (-> arg0 quad) (-> s5-0 vec quad)) + (vector-negate! arg0 arg0) + (if (= (vector-normalize-ret-len! arg0 1.0) 0.0) + (set! (-> arg0 y) 1.0) + ) + f30-1 + ) + ) + ) + +(defun quaternion-seek ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float) (arg4 float)) + (let ((s5-0 (new-stack-matrix0)) + (s4-0 (new-stack-matrix0)) + ) + (quaternion->matrix s5-0 arg1) + (quaternion->matrix s4-0 arg2) + (let ((s2-1 (new-stack-quaternion0))) + (quaternion-from-two-vectors-max-angle! + s2-1 + (the-as vector (&-> s5-0 data 8)) + (the-as vector (&-> s4-0 data 8)) + arg4 + ) + (quaternion-normalize! (quaternion*! arg0 arg0 s2-1)) + ) + ) + ) + +(defun vector-deg-seek ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (let ((s4-0 (new-stack-matrix0))) + (matrix-from-two-vectors-max-angle! s4-0 arg1 arg2 arg3) + (vector-matrix*! arg0 arg1 s4-0) + ) + ) + +(defun vector-deg-slerp ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (cond + ((>= 0.0 arg3) + (set! (-> arg0 quad) (-> arg1 quad)) + arg0 + ) + ((>= arg3 1.0) + (set! (-> arg0 quad) (-> arg2 quad)) + arg0 + ) + (else + (let ((s1-0 (new-stack-matrix0))) + (let ((s2-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) arg1 1.0)) + (a2-3 (vector-normalize-copy! (new 'stack-no-clear 'vector) arg2 1.0)) + ) + (matrix-from-two-vectors-partial-linear! s1-0 s2-0 a2-3 arg3) + ) + (vector-matrix*! arg0 arg1 s1-0) + ) + ) + ) + ) + +(defun vector-vector-deg-slerp! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float) (arg4 vector)) + (local-vars (sv-112 (function float float float float))) + (cond + ((>= 0.0 arg3) + (set! (-> arg0 quad) (-> arg1 quad)) + ) + ((>= arg3 1.0) + (set! (-> arg0 quad) (-> arg2 quad)) + ) + (else + (let* ((s0-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) arg1 1.0)) + (s1-0 (vector-normalize-copy! (new 'stack-no-clear 'vector) arg2 1.0)) + (s0-1 (forward-up->quaternion (new 'stack-no-clear 'quaternion) s0-0 arg4)) + (a2-5 (forward-up->quaternion (new 'stack-no-clear 'quaternion) s1-0 arg4)) + (a1-6 (quaternion-slerp! (new 'stack-no-clear 'quaternion) s0-1 a2-5 arg3)) + (s2-1 vector-normalize-copy!) + (s1-1 arg0) + (s0-2 (vector-z-quaternion! (new 'stack-no-clear 'vector) a1-6)) + ) + (set! sv-112 lerp) + (let ((s3-1 (vector-length arg1)) + (a1-7 (vector-length arg2)) + ) + (s2-1 s1-1 s0-2 (sv-112 s3-1 a1-7 arg3)) + ) + ) + ) + ) + arg0 + ) + +(defun normal-of-plane ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + ) + (init-vf0-vector) + (.lvf vf3 (&-> arg2 quad)) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg3 quad)) + (.sub.vf vf1 vf3 vf1) + (.sub.vf vf2 vf3 vf2) + (.outer.product.a.vf acc vf2 vf1) + (.outer.product.b.vf vf4 vf1 vf2 acc) + (.mul.vf vf5 vf4 vf4) + (.add.y.vf vf5 vf5 vf5 :mask #b1) + (.add.z.vf vf5 vf5 vf5 :mask #b1) + (.isqrt.vf Q vf0 vf5 :fsf #b11 :ftf #b0) + (.mov.vf vf4 vf0 :mask #b1000) + (.wait.vf) + (.mul.vf vf4 vf4 Q :mask #b111) + (.nop.vf) + (.nop.vf) + (.svf (&-> arg0 quad) vf4) + arg0 + ) + ) + +(defun vector-3pt-cross! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.lvf vf3 (&-> arg3 quad)) + (.add.x.vf vf4 vf0 vf0 :mask #b1000) + (.sub.vf vf2 vf2 vf1) + (.sub.vf vf3 vf3 vf1) + (.outer.product.a.vf acc vf2 vf3) + (.outer.product.b.vf vf4 vf3 vf2 acc) + (.svf (&-> arg0 quad) vf4) + arg0 + ) + ) + +(defun closest-pt-in-triangle ((arg0 vector) (arg1 vector) (arg2 matrix) (arg3 vector)) + "arg2 is the vertices of the triangle, arg3 is the normal, arg1 is the input point, arg0 is the output." + ;; (declare (print-asm)) + (local-vars + (v1-0 uint) + (v1-4 uint) + (v1-5 uint) + (v1-6 uint) + (v1-7 uint) + (v1-10 uint) + (a0-1 uint) + (a1-1 uint) + ) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf10 :class vf) + (vf11 :class vf) + (vf12 :class vf) + (vf13 :class vf) + (vf14 :class vf) + (vf15 :class vf) + (vf16 :class vf) + (vf17 :class vf) + (vf18 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + (vf8 :class vf) + (vf9 :class vf) + ) + (init-vf0-vector) + (nop!) + (nop!) + (.lvf vf3 (&-> arg2 vector 1 quad)) + (nop!) + (.lvf vf4 (&-> arg2 vector 2 quad)) + (nop!) + (.lvf vf5 (&-> arg1 quad)) + (.sub.vf vf6 vf3 vf4) + (.lvf vf2 (&-> arg2 vector 0 quad)) + (.sub.vf vf7 vf3 vf5) + (.lvf vf1 (&-> arg3 quad)) + (.sub.vf vf8 vf3 vf2) + (.sub.vf vf9 vf5 vf4) + (.sub.vf vf10 vf5 vf2) + (.outer.product.a.vf acc vf7 vf8) + (.outer.product.b.vf vf14 vf8 vf7 acc) + (.outer.product.a.vf acc vf6 vf7) + (.outer.product.b.vf vf15 vf7 vf6 acc) + (.mul.vf vf11 vf14 vf1) + (.outer.product.a.vf acc vf9 vf10) + (.outer.product.b.vf vf16 vf10 vf9 acc) + (.mul.vf vf12 vf15 vf1) + (.add.x.vf vf11 vf11 vf11 :mask #b10) + (.mul.vf vf13 vf16 vf1) + (.add.x.vf vf12 vf12 vf12 :mask #b10) + (.add.x.vf vf13 vf13 vf13 :mask #b10) + (.add.z.vf vf11 vf11 vf11 :mask #b10) + (.add.z.vf vf12 vf12 vf12 :mask #b10) + (.add.z.vf vf13 vf13 vf13 :mask #b10) + ;; note: these types were changed to uint to make this copy 64 bits. + (.mov v1-0 vf11) + (.mov a1-1 vf12) + (.mov a0-1 vf13) + (let* ((v1-1 (shr (the-as int v1-0) 63)) + (a1-2 (shr (the-as int a1-1) 63)) + (a0-2 (shr (the-as int a0-1) 63)) + (a1-3 (* a1-2 2)) + (a0-3 (* a0-2 4)) + (v1-3 (logior (logior v1-1 a1-3) a0-3)) + ) + (b! (nonzero? v1-3) cfg-3 :delay (set! v1-4 (the-as uint (+ v1-3 -1)))) + ) + (.sub.vf vf17 vf5 vf2) + (.mov.vf vf18 vf0 :mask #b1000) + (.outer.product.a.vf acc vf17 vf1) + (.outer.product.b.vf vf18 vf1 vf17 acc) + (.outer.product.a.vf acc vf1 vf18) + (.outer.product.b.vf vf18 vf18 vf1 acc) + (.add.vf vf18 vf18 vf2 :mask #b111) + (b! #t cfg-24 :delay (.svf (&-> arg0 quad) vf18)) + (nop!) + (label cfg-3) + (b! (nonzero? v1-4) cfg-6 :delay (set! v1-5 (the-as uint (+ v1-4 -1)))) + (vector-segment-distance-point! + arg1 + (the-as vector (-> arg2 vector)) + (-> arg2 vector 1) + arg0 + ) + (goto cfg-24) + (label cfg-6) + (b! (nonzero? v1-5) cfg-9 :delay (set! v1-6 (the-as uint (+ v1-5 -1)))) + (vector-segment-distance-point! + arg1 + (-> arg2 vector 1) + (-> arg2 vector 2) + arg0 + ) + (goto cfg-24) + (label cfg-9) + (b! (nonzero? v1-6) cfg-14 :delay (set! v1-7 (the-as uint (+ v1-6 -1)))) + (let ((f30-0 (vector-segment-distance-point! + arg1 + (-> arg2 vector 1) + (the-as vector (-> arg2 vector)) + arg0 + ) + ) + (s3-0 (new 'stack-no-clear 'vector)) + ) + (if (< (vector-segment-distance-point! + arg1 + (-> arg2 vector 1) + (-> arg2 vector 2) + s3-0 + ) + f30-0 + ) + (set! (-> arg0 quad) (-> s3-0 quad)) + ) + ) + (goto cfg-24) + (label cfg-14) + (b! (nonzero? v1-7) cfg-17 :delay (set! v1-10 (the-as uint (+ v1-7 -1)))) + (vector-segment-distance-point! + arg1 + (-> arg2 vector 2) + (the-as vector (-> arg2 vector)) + arg0 + ) + (goto cfg-24) + (label cfg-17) + (b! (nonzero? v1-10) cfg-22) + (let ((f30-1 (vector-segment-distance-point! + arg1 + (the-as vector (-> arg2 vector)) + (-> arg2 vector 1) + arg0 + ) + ) + (s3-1 (new 'stack-no-clear 'vector)) + ) + (if (< (vector-segment-distance-point! + arg1 + (the-as vector (-> arg2 vector)) + (-> arg2 vector 2) + s3-1 + ) + f30-1 + ) + (set! (-> arg0 quad) (-> s3-1 quad)) + ) + ) + (goto cfg-24) + (label cfg-22) + (let ((f30-2 (vector-segment-distance-point! + arg1 + (-> arg2 vector 2) + (the-as vector (-> arg2 vector)) + arg0 + ) + ) + (s3-2 (new 'stack-no-clear 'vector)) + ) + (if (< (vector-segment-distance-point! + arg1 + (-> arg2 vector 2) + (-> arg2 vector 1) + s3-2 + ) + f30-2 + ) + (set! (-> arg0 quad) (-> s3-2 quad)) + ) + ) + (label cfg-24) + 0 + (none) + ) + ) + +(defun point-in-triangle-cross ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector) (arg4 vector)) + "Check if point is in the triangle using cross product check (so you have to get the order of points right)" + (local-vars (v1-0 int) (a0-1 int) (a1-1 int)) + (rlet ((acc :class vf) + (vf1 :class vf) + (vf10 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + (vf8 :class vf) + (vf9 :class vf) + ) + (.lvf vf3 (&-> arg3 quad)) + (.lvf vf4 (&-> arg4 quad)) + (.lvf vf5 (&-> arg0 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.lvf vf1 (&-> arg1 quad)) + (.sub.vf vf6 vf3 vf4) + (.sub.vf vf7 vf3 vf5) + (.sub.vf vf8 vf3 vf2) + (.sub.vf vf9 vf5 vf4) + (.sub.vf vf10 vf5 vf2) + (.outer.product.a.vf acc vf6 vf7) + (.outer.product.b.vf vf2 vf7 vf6 acc) + (.outer.product.a.vf acc vf7 vf8) + (.outer.product.b.vf vf3 vf8 vf7 acc) + (.outer.product.a.vf acc vf9 vf10) + (.outer.product.b.vf vf4 vf10 vf9 acc) + (.mul.vf vf2 vf2 vf1) + (.mul.vf vf3 vf3 vf1) + (.nop.vf) + (.mul.vf vf4 vf4 vf1) + (.add.x.vf vf2 vf2 vf2 :mask #b10) + (.add.x.vf vf3 vf3 vf3 :mask #b10) + (.add.x.vf vf4 vf4 vf4 :mask #b10) + (.nop.vf) + (.add.z.vf vf2 vf2 vf2 :mask #b10) + (.add.z.vf vf3 vf3 vf3 :mask #b10) + (.add.z.vf vf4 vf4 vf4 :mask #b10) + (.nop.vf) + (.mov a0-1 vf2) + (.mov a1-1 vf3) + (.mov v1-0 vf4) + (>= (the-as int (logior (logior a0-1 a1-1) v1-0)) 0) + ) + ) + +(defun point-in-plane-<-point+normal! ((arg0 vector) (arg1 vector) (arg2 vector)) + (let ((f0-3 (+ (* (-> arg2 x) (-> arg1 x)) (* (-> arg2 y) (-> arg1 y)) (* (-> arg2 z) (-> arg1 z))))) + (set! (-> arg0 w) 1.0) + (let ((f1-7 (fabs (-> arg2 x))) + (f2-3 (fabs (-> arg2 y))) + (f3-1 (fabs (-> arg2 z))) + ) + (cond + ((and (< f2-3 f1-7) (< f3-1 f1-7)) + (set! (-> arg0 y) (+ 4096.0 (-> arg1 y))) + (set! (-> arg0 z) (+ 4096.0 (-> arg1 z))) + (set! (-> arg0 x) (/ (+ (- (- (* (-> arg2 y) (-> arg0 y))) (* (-> arg2 z) (-> arg0 z))) f0-3) (-> arg2 x))) + ) + ((and (< f1-7 f2-3) (< f3-1 f2-3)) + (set! (-> arg0 x) (+ 4096.0 (-> arg1 x))) + (set! (-> arg0 z) (+ 4096.0 (-> arg1 z))) + (set! (-> arg0 y) (/ (- (- f0-3 (* (-> arg2 x) (-> arg0 x))) (* (-> arg2 z) (-> arg0 z))) (-> arg2 y))) + ) + (else + (set! (-> arg0 x) (+ 4096.0 (-> arg1 x))) + (set! (-> arg0 y) (+ 4096.0 (-> arg1 y))) + (set! (-> arg0 z) (/ (+ (- (- (* (-> arg2 x) (-> arg0 x))) (* (-> arg2 y) (-> arg0 y))) f0-3) (-> arg2 z))) + ) + ) + ) + ) + arg0 + ) + +(defun circle-circle-xz-intersect ((arg0 sphere) (arg1 sphere) (arg2 vector) (arg3 vector)) + (format 0 "circle-circle-xz-intersect~%") + (break!) + 0 + ) + +(defun circle-test () + (let ((s4-0 (new 'stack 'sphere)) + (a1-2 (new 'stack 'sphere)) + (s5-0 (new-stack-vector0)) + (gp-0 (new-stack-vector0)) + ) + (set-vector! s4-0 0.0 0.0 0.0 1.0) + (set-vector! a1-2 100.0 0.0 0.0 10000.0) + (let ((a2-1 (circle-circle-xz-intersect s4-0 a1-2 s5-0 gp-0))) + (format #t "res = ~d~%" a2-1) + ) + (format #t "(~f, ~f)~%" (-> s5-0 x) (-> s5-0 z)) + (format #t "(~f, ~f)~%" (-> gp-0 x) (-> gp-0 z)) + ) + (none) + ) + +(defun vector-circle-tangent-new ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector)) + (rlet ((Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + ) + (init-vf0-vector) + (let ((a1-2 (new 'stack 'sphere))) + (set! (-> (new 'stack-no-clear 'vector) quad) (the-as uint128 0)) + (set! (-> (new 'stack-no-clear 'vector) quad) (the-as uint128 0)) + (let ((v1-3 #x3f000000)) + (.lvf vf3 (&-> arg1 quad)) + (.mov vf2 v1-3) + ) + (.lvf vf4 (&-> arg0 quad)) + (.add.vf vf1 vf3 vf4) + (.sub.vf vf5 vf4 vf3) + (.mul.x.vf vf1 vf1 vf2) + (.mul.x.vf vf5 vf5 vf2) + (.mul.vf vf5 vf5 vf5 :mask #b101) + (.add.z.vf vf5 vf5 vf5 :mask #b1) + (.sqrt.vf Q vf5 :ftf #b0) + (.wait.vf) + (.mul.vf vf1 vf0 Q :mask #b1000) + (.nop.vf) + (.nop.vf) + (.svf (&-> a1-2 quad) vf1) + (circle-circle-xz-intersect (the-as sphere arg1) a1-2 arg2 arg3) + ) + 0 + (none) + ) + ) + +(defun vector-circle-tangent ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector)) + (let* ((s3-1 (vector-! (the-as vector (new 'stack-no-clear 'sphere)) arg1 arg0)) + (f0-0 (vector-xz-length s3-1)) + (f28-0 (acos (/ (-> arg1 w) f0-0))) + ) + (cond + ((>= 546.13336 f28-0) + (set! (-> arg2 x) (- (-> arg0 x) (-> s3-1 z))) + (set! (-> arg2 y) 0.0) + (set! (-> arg2 z) (+ (-> arg0 z) (-> s3-1 x))) + (set! (-> arg3 x) (+ (-> arg0 x) (-> s3-1 z))) + (set! (-> arg3 y) 0.0) + (set! (-> arg3 z) (- (-> arg0 z) (-> s3-1 x))) + ) + (else + (let ((f0-15 (atan (-> s3-1 z) (-> s3-1 x))) + (f30-0 (- (-> arg1 w))) + (s3-2 (new 'stack-no-clear 'vector)) + ) + (let ((s2-1 (new 'stack-no-clear 'vector))) + (let ((a2-1 (new 'stack-no-clear 'vector))) + (set! (-> a2-1 x) (- f0-15 f28-0)) + (set! (-> a2-1 y) (+ f0-15 f28-0)) + (vector-sincos! s3-2 s2-1 a2-1) + ) + (set! (-> arg2 x) (+ (-> arg1 x) (* f30-0 (-> s2-1 x)))) + (set! (-> arg2 z) (+ (-> arg1 z) (* f30-0 (-> s3-2 x)))) + (set! (-> arg3 x) (+ (-> arg1 x) (* f30-0 (-> s2-1 y)))) + ) + (set! (-> arg3 z) (+ (-> arg1 z) (* f30-0 (-> s3-2 y)))) + ) + ) + ) + ) + 0 + (none) + ) + +(defun find-knot-span ((arg0 int) (arg1 int) (arg2 float) (arg3 (inline-array vector))) + (local-vars (v0-0 int)) + (b! (= arg2 (-> (&-> arg3 0 data (+ arg0 1)) 0)) cfg-11 :delay (set! v0-0 arg0)) + (let ((v1-3 (the int arg2))) + (let* ((a2-1 (+ v1-3 3)) + (t0-1 (&-> arg3 0 data a2-1)) + (f1-2 (-> t0-1 0)) + (f2-0 (-> t0-1 1)) + ) + (b! (> f1-2 arg2) cfg-4) + (b! (>= arg2 f2-0) cfg-4 :delay (set! v0-0 a2-1)) + ) + (b! #t cfg-11 :delay (nop!)) + (label cfg-4) + (let ((a1-1 arg1) + (a0-1 (+ arg0 1)) + ) + (label cfg-5) + (let ((a2-3 (/ (+ a1-1 a0-1) 2))) + (let ((t0-3 (&-> arg3 0 data a2-3))) + (b! (>= arg2 (-> t0-3 0)) cfg-7) + (b! #t cfg-5 :delay (set! a0-1 a2-3)) + (label cfg-7) + (b! (< arg2 (-> t0-3 1)) cfg-9) + ) + (b! #t cfg-5 :delay (set! a1-1 a2-3)) + (label cfg-9) + (set! v0-0 a2-3) + ) + ) + (b! (= v0-0 v1-3) cfg-11 :delay (nop!)) + ) + (nop!) + (nop!) + (label cfg-11) + v0-0 + ) + +(defun calculate-basis-functions-vector! ((arg0 vector) (arg1 int) (arg2 float) (arg3 (pointer float))) + "Calculate polynomial basis for a given control point." + (local-vars (v1-0 int) (v1-1 object)) + ;;(.sll v1-0 arg1 2) + (set! v1-0 (* 4 arg1)) ;; originally used 32-bit asm + (let ((a1-1 #x3f800000) + (f3-0 arg2) + ) + ;;(.addu v1-1 arg3 v1-0) + (set! v1-1 (&+ arg3 v1-0)) + (let* ((f1-0 (the-as float a1-1)) ;; trick to load float constant. + (f5-0 f1-0) + ) + 0.0 + 0.0 + (let* ((f0-2 (-> (the-as (pointer float) v1-1) 0)) + (f2-0 (-> (the-as (pointer float) v1-1) 1)) + (f0-3 (- f3-0 f0-2)) + (f4-0 (- f2-0 f3-0)) + (f10-0 (/ f1-0 (+ f4-0 f0-3))) + (f2-2 (-> (the-as (pointer float) v1-1) -1)) + (f8-0 (-> (the-as (pointer float) v1-1) 2)) + (f2-3 (- f3-0 f2-2)) + (f9-0 (+ f4-0 f2-3)) + (f6-0 (-> (the-as (pointer float) v1-1) -2)) + (f7-0 (-> (the-as (pointer float) v1-1) 3)) + (f9-1 (/ f1-0 f9-0)) + (f5-1 (* f5-0 f10-0)) + (f11-0 (* f4-0 f5-1)) + (f10-1 (* f0-3 f5-1)) + (f5-2 (- f8-0 f3-0)) + (f8-1 (* f11-0 f9-1)) + (f11-1 (/ f1-0 (+ f5-2 f0-3))) + (f9-3 (* f4-0 f8-1)) + (f8-2 (* f2-3 f8-1)) + (f11-2 (* f10-1 f11-1)) + (f10-3 (+ (* f5-2 f11-2) f8-2)) + (f8-3 (* f0-3 f11-2)) + (f6-1 (- f3-0 f6-0)) + (f3-1 (- f7-0 f3-0)) + (f7-3 (* f9-3 (/ f1-0 (+ f4-0 f6-1)))) + (f4-1 (* f4-0 f7-3)) + (f6-2 (* f6-1 f7-3)) + (f7-6 (* f10-3 (/ f1-0 (+ f5-2 f2-3)))) + (f5-4 (+ (* f5-2 f7-6) f6-2)) + (f2-4 (* f2-3 f7-6)) + (f1-2 (* f8-3 (the-as float (/ f1-0 (+ f3-1 f0-3))))) + (f2-5 (+ (* f3-1 f1-2) f2-4)) + (f0-4 (* f0-3 f1-2)) + ) + (set! (-> arg0 x) f4-1) + (set! (-> arg0 y) f5-4) + (set! (-> arg0 z) f2-5) + (set! (-> arg0 w) f0-4) + ) + ) + ) + arg0 + ) + +(defun curve-evaluate! ((arg0 vector) (arg1 float) (arg2 (inline-array vector)) (arg3 int) (arg4 (pointer float)) (arg5 int)) + "Evaluate a curve. + arg0 is the output + arg1 is the input. + arg2 is control vertices + arg3 is the number of control vertices + arg4 is the knot points + arg5 is the number of knots + " + (local-vars (v1-7 int) (v1-8 int) (v1-10 float) (s3-0 int)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (init-vf0-vector) + (let ((s4-0 (new 'static 'vector))) + 0 + ;; lookup knot + (let* ((f0-0 (-> arg4 0)) + (f1-0 (-> (&-> arg4 (+ arg5 -1)) 0)) + (a2-1 (fmax (fmin (* arg1 f1-0) f1-0) f0-0)) + ) + (let* ((a1-1 (+ arg5 -5)) + (a3-1 3) + (f0-2 a2-1) + (v1-5 arg4) + (f0-3 f0-2) + ) + (b! (= f0-3 (-> (&-> v1-5 (+ a1-1 1)) 0)) + cfg-11 + :delay (set! s3-0 a1-1) + ) + (let ((a0-4 (the int f0-3))) + (let* ((t1-1 (+ a0-4 3)) + (t2-1 (&-> v1-5 t1-1)) + (f1-4 (-> t2-1 0)) + (f2-3 (-> t2-1 1)) + ) + (b! (> f1-4 f0-3) cfg-4) + (b! (>= f0-3 f2-3) cfg-4 :delay (set! s3-0 t1-1)) + ) + (b! #t cfg-11) + (label cfg-4) + (let ((a3-2 a3-1) + (a1-2 (+ a1-1 1)) + ) + (label cfg-5) + (let ((t1-3 (/ (+ a3-2 a1-2) 2))) + (let ((t2-3 (&-> v1-5 t1-3))) + (b! (>= f0-3 (-> t2-3 0)) cfg-7) + (b! #t cfg-5 :delay (set! a1-2 t1-3)) + (label cfg-7) + (b! (< f0-3 (-> t2-3 1)) cfg-9) + ) + (b! #t cfg-5 :delay (set! a3-2 t1-3)) + (label cfg-9) + (set! s3-0 t1-3) + ) + ) + (b! (= s3-0 a0-4) cfg-11) + ) + ) + (nop!) + (nop!) + (label cfg-11) + ;; calculate coefficients for this knot's polynomial, store in s4-0 + (calculate-basis-functions-vector! + s4-0 + s3-0 + a2-1 + (the-as (pointer float) arg4) + ) + ) + ;;(.addiu v1-7 s3-0 -3) + (set! v1-7 (- s3-0 3)) + (.lvf vf6 s4-0) + ) + ;; evaluate polynomial! + ;;(.sll v1-8 v1-7 4) + (set! v1-8 (* v1-7 16)) + (.add.x.vf vf1 vf0 vf0 :mask #b1000) + (let ((v1-9 (+ v1-8 (the-as int arg2)))) + (nop!) + (nop!) + (.lvf vf2 (&-> (the-as (pointer int128) v1-9))) + (nop!) + (.lvf vf3 (+ v1-9 16)) + (nop!) + (.lvf vf4 (+ v1-9 32)) + (nop!) + (.lvf vf5 (+ v1-9 48)) + ) + (.mul.x.vf acc vf2 vf6) + (nop!) + (.add.mul.y.vf acc vf3 vf6 acc :mask #b111) + (nop!) + (.add.mul.z.vf acc vf4 vf6 acc :mask #b111) + (nop!) + (.add.mul.w.vf vf1 vf5 vf6 acc :mask #b111) + (nop!) + (nop!) + (nop!) + (nop!) + (nop!) + (nop!) + (nop!) + (nop!) + (.svf (&-> arg0 quad) vf1) + (.mov v1-10 vf1) + arg0 + ) + ) + +(defun curve-get-pos! ((arg0 vector) (arg1 float) (arg2 curve)) + (curve-evaluate! arg0 arg1 (-> arg2 cverts) (-> arg2 num-cverts) (-> arg2 knots) (-> arg2 num-knots)) + ) + +(defun curve-length ((arg0 curve)) + (let ((s5-0 (new 'stack-no-clear 'vector)) + (s4-0 (new 'stack-no-clear 'vector)) + (s3-0 (* 3 (-> arg0 num-cverts))) + (f30-0 0.0) + ) + (when (nonzero? s3-0) + (curve-evaluate! + s4-0 + (-> arg0 knots 0) + (-> arg0 cverts) + (-> arg0 num-cverts) + (-> arg0 knots) + (-> arg0 num-knots) + ) + (dotimes (s2-0 s3-0) + (set! (-> s5-0 quad) (-> s4-0 quad)) + (curve-evaluate! + s4-0 + (/ (the float (+ s2-0 1)) (the float s3-0)) + (-> arg0 cverts) + (-> arg0 num-cverts) + (-> arg0 knots) + (-> arg0 num-knots) + ) + (+! f30-0 (vector-vector-distance s5-0 s4-0)) + ) + ) + f30-0 + ) + ) + +(defun curve-copy! ((arg0 curve) (arg1 curve)) + (set! (-> arg0 cverts) (-> arg1 cverts)) + (set! (-> arg0 num-cverts) (-> arg1 num-cverts)) + (set! (-> arg0 knots) (-> arg1 knots)) + (set! (-> arg0 num-knots) (-> arg1 num-knots)) + (set! (-> arg0 length) (-> arg1 length)) + arg0 + ) + +(defun curve-closest-point ((arg0 curve) (arg1 vector) (arg2 float) (arg3 float) (arg4 int) (arg5 float)) + (local-vars (sv-48 float)) + (set! sv-48 arg3) + (let ((s3-0 arg4) + (gp-0 arg5) + (f30-0 (curve-length arg0)) + (s2-0 (new 'stack-no-clear 'vector)) + (s1-0 (new 'stack-no-clear 'vector)) + ) + 0.0 + 0.0 + 0.0 + 0.0 + (let ((f28-0 0.5)) + 0.0 + (if (< 0.0 sv-48) + (set! f28-0 (/ sv-48 f30-0)) + ) + (let* ((s0-1 (- arg2 (/ gp-0 f30-0))) + (f26-0 (- s0-1 f28-0)) + (f24-0 (+ s0-1 f28-0)) + ) + (curve-get-pos! s2-0 f26-0 arg0) + (curve-get-pos! s1-0 f24-0 arg0) + (let ((f22-0 (vector-vector-distance-squared s2-0 arg1)) + (f20-0 (vector-vector-distance-squared s1-0 arg1)) + ) + (while (> s3-0 0) + (+! s3-0 -1) + (set! f28-0 (* 0.5 f28-0)) + (let ((v1-6 (cond + ((< f22-0 f20-0) + (curve-get-pos! s1-0 s0-1 arg0) + (set! f20-0 (vector-vector-distance-squared s1-0 arg1)) + (set! f24-0 s0-1) + (- s0-1 f28-0) + ) + (else + (curve-get-pos! s2-0 s0-1 arg0) + (set! f22-0 (vector-vector-distance-squared s2-0 arg1)) + (set! f26-0 s0-1) + (+ s0-1 f28-0) + ) + ) + ) + ) + (set! s0-1 (fmin 1.0 (fmax 0.0 v1-6))) + ) + ) + (+ (if (< f22-0 f20-0) + f26-0 + f24-0 + ) + (/ gp-0 f30-0) + ) + ) + ) + ) + ) + ) + +(defun vector-plane-distance ((arg0 vector) (arg1 plane) (arg2 vector)) + (vector-dot (vector-! (new 'stack-no-clear 'vector) arg0 (the-as vector (&-> arg1 x))) arg2) + ) + +(defun intersect-ray-plane ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector)) + (let ((f0-1 (vector-dot arg3 arg1))) + (the-as float (if (= f0-1 0.0) + -1082130432 + (/ (- (vector-dot arg3 arg0) (vector-dot arg3 arg2)) (- f0-1)) + ) + ) + ) + ) + + + + diff --git a/goal_src/jak2/engine/gfx/hw/display-h.gc b/goal_src/jak2/engine/gfx/hw/display-h.gc index a50c5f2141..ce9c4c52bd 100644 --- a/goal_src/jak2/engine/gfx/hw/display-h.gc +++ b/goal_src/jak2/engine/gfx/hw/display-h.gc @@ -5,3 +5,105 @@ ;; name in dgo: display-h ;; dgos: ENGINE, GAME +(declare-type display basic) + +(define-extern set-display (function display int int int int int display)) + +(deftype display-frame (basic) + ((buffer dma-buffer 11 :offset-assert 4) + (calc-buf dma-buffer :offset 8) + (vu1-buf dma-buffer :offset 8) + (debug-buf dma-buffer :offset 36) + (global-buf dma-buffer :offset 40) + (bucket-group dma-bucket :offset 44) + (profile-array profile-array :inline :offset-assert 48) + (start-time uint64 :offset-assert 56) + (run-time uint64 :offset-assert 64) + ) + (:methods + (new (symbol type) _type_ 0) + ) + :method-count-assert 9 + :size-assert #x48 + :flag-assert #x900000048 + ) + +(defmethod new display-frame ((allocation symbol) (type-to-make type)) + (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (set! (-> gp-0 calc-buf) (the-as dma-buffer 0)) + (set! (-> gp-0 global-buf) (the-as dma-buffer 0)) + (set! (-> gp-0 debug-buf) (the-as dma-buffer 0)) + (when *debug-segment* + (set! (-> gp-0 profile-array data 0) (new 'debug 'profile-segment-array)) + (set! (-> gp-0 profile-array data 1) (new 'debug 'profile-segment-array)) + ) + gp-0 + ) + ) + +(deftype display (basic) + ((on-screen int32 :offset-assert 4) + (last-screen int32 :offset-assert 8) + (frames display-frame 2 :offset-assert 12) + (bgcolor uint64 :offset-assert 24) + (pmode gs-pmode :offset-assert 32) + (clock clock 13 :offset-assert 40) + (session-clock clock :offset 40) + (game-clock clock :offset 44) + (base-clock clock :offset 48) + (real-clock clock :offset 52) + (frame-clock clock :offset 56) + (real-frame-clock clock :offset 60) + (target-clock clock :offset 64) + (entity-clock clock :offset 68) + (part-clock clock :offset 72) + (bg-clock clock :offset 76) + (camera-clock clock :offset 80) + (user0-clock clock :offset 84) + (total-game-clock clock :offset 88) + (time-factor float :offset-assert 92) + (dog-ratio float :offset-assert 96) + (vblank-start-time uint64 2 :offset-assert 104) + (total-run-time uint64 :offset-assert 120) + (run-half-speed basic :offset-assert 128) + (dog-count float :offset-assert 132) + (vu1-enable-user vu1-renderer-mask :offset-assert 136) + (vu1-enable-user-menu vu1-renderer-mask :offset-assert 144) + (force-sync uint32 :offset-assert 152) + ) + :method-count-assert 10 + :size-assert #x9c + :flag-assert #xa0000009c + (:methods + (new (symbol type int int int int int) _type_ 0) + (dummy-9 () none 9) + ) + ) + +(defmethod new display ((allocation symbol) (type-to-make type) (arg0 int) (arg1 int) (arg2 int) (arg3 int) (arg4 int)) + (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (set-display gp-0 arg0 arg1 arg2 arg3 arg4) + (set! (-> gp-0 frames 0) (new 'global 'display-frame)) + (set! (-> gp-0 frames 1) (new 'global 'display-frame)) + (set! (-> gp-0 pmode) (new 'static 'gs-pmode :en1 #x1 :crtmd #x1 :mmod #x1 :slbg #x1)) + (set! (-> gp-0 run-half-speed) #f) + (set! (-> gp-0 vu1-enable-user-menu) + (vu1-renderer-mask rn3 rn4 rn5 rn6 rn7 rn8 rn9 rn10 rn11 rn12 rn13 rn14 rn15 + rn16 rn17 rn18 rn19 rn20 rn21 rn22 rn23 rn24 rn25 rn26 rn27 rn28 + rn29 rn30 rn31 rn32 rn34 + ) + ) + (set! (-> gp-0 vu1-enable-user) + (vu1-renderer-mask rn3 rn4 rn5 rn6 rn7 rn8 rn9 rn10 rn11 rn12 rn13 rn14 rn15 + rn16 rn17 rn18 rn19 rn20 rn21 rn22 rn23 rn24 rn25 rn26 rn27 rn28 + rn29 rn30 rn31 rn32 rn34 + ) + ) + gp-0 + ) + ) + +(define *pre-draw-hook* (the-as (function object none) nothing)) +(define *post-draw-hook* (the-as (function dma-buffer none) nothing)) + +(define-extern *display* display) \ No newline at end of file diff --git a/goal_src/jak2/engine/gfx/hw/gs.gc b/goal_src/jak2/engine/gfx/hw/gs.gc index 50166fa2f3..178d022913 100644 --- a/goal_src/jak2/engine/gfx/hw/gs.gc +++ b/goal_src/jak2/engine/gfx/hw/gs.gc @@ -5,3 +5,975 @@ ;; name in dgo: gs ;; dgos: ENGINE, GAME +(defenum gs-psm + :bitfield #f + :type uint8 + (ct32 0) + (ct24 1) + (ct16 2) + (ct16s 10) + (mt8 19) + (mt4 20) + (mt8h 27) + (mt4hl 36) + (mt4hh 44) + (mz32 48) + (mz24 49) + (mz16 50) + (mz16s 58) + ) + +(defenum gs-reg + :type uint8 + (prim 0) + (rgbaq 1) + (st 2) + (uv 3) + (xyzf2 4) + (xyz2 5) + (tex0-1 6) + (tex0-2 7) + (clamp-1 8) + (clamp-2 9) + (fog 10) + (xyzf3 12) + (xyz3 13) + (tex1-1 20) + (tex1-2 21) + (tex2-1 22) + (tex2-2 23) + (xyoffset-1 24) + (xyoffset-2 25) + (prmodecont 26) + (prmode 27) + (texclut 28) + (scanmsk 34) + (miptbp1-1 52) + (miptbp1-2 53) + (miptbp2-1 54) + (miptbp2-2 55) + (texa 59) + (fogcol 61) + (texflush 63) + (scissor-1 64) + (scissor-2 65) + (alpha-1 66) + (alpha-2 67) + (dimx 68) + (dthe 69) + (colclamp 70) + (test-1 71) + (test-2 72) + (pabe 73) + (fba-1 74) + (fba-2 75) + (frame-1 76) + (frame-2 77) + (zbuf-1 78) + (zbuf-2 79) + (bitbltbuf 80) + (trxpos 81) + (trxreg 82) + (trxdir 83) + (hwreg 84) + (signal 96) + (finish 97) + (label 98) + ) + +(defenum gs-atest + :type uint8 + (never 0) + (always 1) + (less 2) + (less-equal 3) + (equal 4) + (greater-equal 5) + (greater 6) + (not-equal 7) + ) +(defenum gs-ztest + :type uint8 + (never 0) + (always 1) + (greater-equal 2) + (greater 3) + ) + +(defenum gs-reg64 + :type uint64 + :copy-entries gs-reg + ) + +(defenum gs-prim-type + :type uint8 + (point 0) + (line 1) + (line-strip 2) + (tri 3) + (tri-strip 4) + (tri-fan 5) + (sprite 6) + ) + +(defenum gs-tex-wrap-mode + :type uint8 + (repeat 0) + (clamp 1) + (region-clamp 2) + (region-repeat 3) + ) + +(defenum gif-flag + :type uint8 + (packed 0) + (reg-list 1) + (image 2) + (disable 3) + ) +(defenum gif-reg-id + :type uint8 + (prim 0) + (rgbaq 1) + (st 2) + (uv 3) + (xyzf2 4) + (xyz2 5) + (tex0-1 6) + (tex0-2 7) + (clamp-1 8) + (clamp-2 9) + (fog 10) + (xyzf3 12) + (xyz3 13) + (a+d 14) + (nop 15) + ) + +(deftype gs-pmode (uint64) + ((en1 uint8 :offset 0 :size 1) + (en2 uint8 :offset 1 :size 1) + (crtmd uint8 :offset 2 :size 3) + (mmod uint8 :offset 5 :size 1) + (amod uint8 :offset 6 :size 1) + (slbg uint8 :offset 7 :size 1) + (alp uint8 :offset 8 :size 8) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-smode2 (uint64) + ((int uint8 :offset 0 :size 1) + (ffmd uint8 :offset 1 :size 1) + (dpms uint8 :offset 2 :size 2) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(defun psm-size ((arg0 gs-psm)) + (cond + ((= arg0 (gs-psm mt8)) + 64 + ) + ((= arg0 (gs-psm mt4)) + 32 + ) + ((or (= arg0 (gs-psm ct16)) (= arg0 (gs-psm ct16s)) (= arg0 (gs-psm mz16)) (= arg0 (gs-psm mz16s))) + 128 + ) + (else + 256 + ) + ) + ) + +(defun psm-page-height ((arg0 gs-psm)) + (cond + ((= arg0 (gs-psm mt8)) + 64 + ) + ((= arg0 (gs-psm mt4)) + 128 + ) + ((or (= arg0 (gs-psm ct16)) (= arg0 (gs-psm ct16s)) (= arg0 (gs-psm mz16)) (= arg0 (gs-psm mz16s))) + 64 + ) + (else + 32 + ) + ) + ) + +(defun psm->string ((arg0 gs-psm)) + (case arg0 + (((gs-psm ct24)) + "ct24" + ) + (((gs-psm mt4)) + "mt4" + ) + (((gs-psm ct32)) + "ct32" + ) + (((gs-psm mz16s)) + "mz16s" + ) + (((gs-psm ct16s)) + "ct16s" + ) + (((gs-psm mt8)) + "mt8" + ) + (((gs-psm mt8h)) + "mt8h" + ) + (((gs-psm mz16)) + "mz16" + ) + (((gs-psm mz24)) + "mz24" + ) + (((gs-psm mt4hh)) + "mt4hh" + ) + (((gs-psm ct16)) + "ct16" + ) + (((gs-psm mt4hl)) + "mt4hl" + ) + (((gs-psm mz32)) + "mz32" + ) + (else + "*unknown*" + ) + ) + ) + +(deftype gs-display-fb (uint64) + ((fbp uint16 :offset 0 :size 9) + (fbw uint8 :offset 9 :size 6) + (psm gs-psm :offset 15 :size 5) + (dbx uint16 :offset 32 :size 11) + (dby uint16 :offset 43 :size 11) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-display (uint64) + ((dx uint16 :offset 0 :size 12) + (dy uint16 :offset 12 :size 11) + (magh uint8 :offset 23 :size 4) + (magv uint8 :offset 27 :size 2) + (dw uint16 :offset 32 :size 12) + (dh uint16 :offset 44 :size 11) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-bgcolor (uint64) + ((r uint8 :offset 0 :size 8) + (g uint8 :offset 8 :size 8) + (b uint8 :offset 16 :size 8) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-csr (uint64) + ((signal uint8 :offset 0 :size 1) + (finish uint8 :offset 1 :size 1) + (hsint uint8 :offset 2 :size 1) + (vsint uint8 :offset 3 :size 1) + (edwint uint8 :offset 4 :size 1) + (flush uint8 :offset 8 :size 1) + (reset uint8 :offset 9 :size 1) + (nfield uint8 :offset 12 :size 1) + (field uint8 :offset 13 :size 1) + (fifo uint8 :offset 14 :size 2) + (rev uint8 :offset 16 :size 8) + (id uint8 :offset 24 :size 8) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-bank (structure) + ((pmode gs-pmode :offset-assert 0) + (smode2 gs-smode2 :offset 32) + (dspfb1 gs-display-fb :offset 112) + (display1 gs-display :offset 128) + (dspfb2 gs-display-fb :offset 144) + (display2 gs-display :offset 160) + (extbuf uint64 :offset 176) + (extdata uint64 :offset 192) + (extwrite uint64 :offset 208) + (bgcolor gs-bgcolor :offset 224) + (csr gs-csr :offset 4096) + (imr uint64 :offset 4112) + (busdir uint64 :offset 4160) + ) + :method-count-assert 9 + :size-assert #x1048 + :flag-assert #x900001048 + ) + +(deftype gs-frame (uint64) + ((fbp uint16 :offset 0 :size 9) + (fbw uint8 :offset 16 :size 6) + (psm gs-psm :offset 24 :size 6) + (fbmsk uint32 :offset 32 :size 32) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-zbuf (uint64) + ((zbp uint16 :offset 0 :size 9) + (psm gs-psm :offset 24 :size 4) + (zmsk uint8 :offset 32 :size 1) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-xy-offset (uint64) + ((ofx uint16 :offset 0 :size 16) + (ofy uint16 :offset 32 :size 16) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-scissor (uint64) + ((scax0 uint16 :offset 0 :size 11) + (scax1 uint16 :offset 16 :size 11) + (scay0 uint16 :offset 32 :size 11) + (scay1 uint16 :offset 48 :size 11) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-prmode-cont (uint64) + ((ac uint8 :offset 0 :size 1) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-color-clamp (uint64) + ((clamp uint8 :offset 0 :size 1) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-dthe (uint64) + ((dthe uint8 :offset 0 :size 1) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-test (uint64) + ((ate uint8 :offset 0 :size 1) + (atst gs-atest :offset 1 :size 3) + (aref uint8 :offset 4 :size 8) + (afail uint8 :offset 12 :size 2) + (date uint8 :offset 14 :size 1) + (datm uint8 :offset 15 :size 1) + (zte uint8 :offset 16 :size 1) + (ztst gs-ztest :offset 17 :size 2) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-prim (uint64) + ((prim gs-prim-type :offset 0 :size 3) + (iip uint8 :offset 3 :size 1) + (tme uint8 :offset 4 :size 1) + (fge uint8 :offset 5 :size 1) + (abe uint8 :offset 6 :size 1) + (aa1 uint8 :offset 7 :size 1) + (fst uint8 :offset 8 :size 1) + (ctxt uint8 :offset 9 :size 1) + (fix uint8 :offset 10 :size 1) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-rgbaq (uint64) + ((r uint8 :offset 0 :size 8) + (g uint8 :offset 8 :size 8) + (b uint8 :offset 16 :size 8) + (a uint8 :offset 24 :size 8) + (q float :offset 32 :size 32) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-xyz (uint64) + ((x uint16 :offset 0 :size 16) + (y uint16 :offset 16 :size 16) + (z uint32 :offset 32 :size 32) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-uv (uint64) + ((u uint16 :offset 0 :size 14) + (v uint16 :offset 16 :size 14) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-st (uint64) + ((s float :offset 0 :size 32) + (t float :offset 32 :size 32) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-xyzf (uint64) + ((x uint16 :offset 0 :size 16) + (y uint16 :offset 16 :size 16) + (z uint32 :offset 32 :size 24) + (f uint8 :offset 56 :size 8) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-adcmd (structure) + ((word uint32 4 :offset-assert 0) + (quad uint128 :offset 0) + (data uint64 :offset 0) + (cmds uint64 :offset 8) + (cmd uint8 :offset 8) + (x uint32 :offset 0) + (y uint32 :offset 4) + (z uint32 :offset 8) + (w uint32 :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype gs-trxpos (uint64) + ((ssax uint16 :offset 0 :size 11) + (ssay uint16 :offset 16 :size 11) + (dsax uint16 :offset 32 :size 11) + (dsay uint16 :offset 48 :size 11) + (dir uint8 :offset 59 :size 2) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-trxreg (uint64) + ((rrw uint16 :offset 0 :size 12) + (rrh uint16 :offset 32 :size 12) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-trxdir (uint64) + ((xdir uint8 :offset 0 :size 2) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-bitbltbuf (uint64) + ((sbp uint16 :offset 0 :size 14) + (sbw uint8 :offset 16 :size 6) + (spsm uint8 :offset 24 :size 6) + (dbp uint16 :offset 32 :size 14) + (dbw uint8 :offset 48 :size 6) + (dpsm uint8 :offset 56 :size 6) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-tex0 (uint64) + ((tbp0 uint16 :offset 0 :size 14) + (tbw uint8 :offset 14 :size 6) + (psm uint8 :offset 20 :size 6) + (tw uint8 :offset 26 :size 4) + (th uint8 :offset 30 :size 4) + (tcc uint8 :offset 34 :size 1) + (tfx uint8 :offset 35 :size 2) + (cbp uint16 :offset 37 :size 14) + (cpsm uint8 :offset 51 :size 4) + (csm uint8 :offset 55 :size 1) + (csa uint8 :offset 56 :size 5) + (cld uint8 :offset 61 :size 3) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-tex1 (uint64) + ((lcm uint8 :offset 0 :size 1) + (mxl uint8 :offset 2 :size 3) + (mmag uint8 :offset 5 :size 1) + (mmin uint8 :offset 6 :size 3) + (mtba uint8 :offset 9 :size 1) + (l uint8 :offset 19 :size 2) + (k int16 :offset 32 :size 12) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-texa (uint64) + ((ta0 uint8 :offset 0 :size 8) + (aem uint8 :offset 15 :size 1) + (ta1 uint8 :offset 32 :size 8) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-texclut (uint64) + ((cbw uint8 :offset 0 :size 6) + (cou uint8 :offset 6 :size 6) + (cov uint16 :offset 12 :size 10) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-miptbp (uint64) + ((tbp1 uint16 :offset 0 :size 14) + (tbw1 uint8 :offset 14 :size 6) + (tbp2 uint16 :offset 20 :size 14) + (tbw2 uint8 :offset 34 :size 6) + (tbp3 uint16 :offset 40 :size 14) + (tbw3 uint8 :offset 54 :size 6) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-alpha (uint64) + ((a uint8 :offset 0 :size 2) + (b uint8 :offset 2 :size 2) + (c uint8 :offset 4 :size 2) + (d uint8 :offset 6 :size 2) + (fix uint8 :offset 32 :size 8) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-clamp (uint64) + ((wms gs-tex-wrap-mode :offset 0 :size 2) + (wmt gs-tex-wrap-mode :offset 2 :size 2) + (minu uint16 :offset 4 :size 10) + (maxu uint16 :offset 14 :size 10) + (minv uint16 :offset 24 :size 10) + (maxv uint16 :offset 34 :size 10) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-fog (uint64) + ((f uint8 :offset 56 :size 8) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gs-fogcol (uint64) + ((fcr uint8 :offset 0 :size 8) + (fcg uint8 :offset 8 :size 8) + (fcb uint8 :offset 16 :size 8) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gif-ctrl (uint32) + ((rst uint8 :offset 0 :size 1) + (pse uint8 :offset 3 :size 1) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype gif-mode (uint32) + ((m3r uint8 :offset 0 :size 1) + (imt uint8 :offset 2 :size 1) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype gif-stat (uint32) + ((m3r uint8 :offset 0 :size 1) + (m3p uint8 :offset 1 :size 1) + (imt uint8 :offset 2 :size 1) + (pse uint8 :offset 3 :size 1) + (ip3 uint8 :offset 5 :size 1) + (p3q uint8 :offset 6 :size 1) + (p2q uint8 :offset 7 :size 1) + (p1q uint8 :offset 8 :size 1) + (oph uint8 :offset 9 :size 1) + (apath uint8 :offset 10 :size 2) + (dir uint8 :offset 12 :size 1) + (fqc uint8 :offset 24 :size 5) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype gif-cnt (uint32) + ((loopcnt uint16 :offset 0 :size 15) + (regcnt uint8 :offset 16 :size 4) + (vuaddr uint16 :offset 20 :size 10) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype gif-p3cnt (uint32) + ((p3cnt uint16 :offset 0 :size 15) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype gif-p3tag (uint32) + ((loopcnt uint16 :offset 0 :size 15) + (eop uint8 :offset 15 :size 1) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype gif-bank (structure) + ((ctrl gif-ctrl :offset 0) + (mode gif-mode :offset 16) + (stat gif-stat :offset 32) + (tag0 uint32 :offset 64) + (tag1 uint32 :offset 80) + (tag2 uint32 :offset 96) + (tag3 uint32 :offset 112) + (cnt gif-cnt :offset 128) + (p3cnt gif-p3cnt :offset 144) + (p3tag gif-p3tag :offset 160) + ) + :method-count-assert 9 + :size-assert #xa4 + :flag-assert #x9000000a4 + ) + +(deftype gif-tag-prim (uint32) + () + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype gif-tag-count (uint32) + () + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype gif-tag64 (uint64) + ((nloop uint16 :offset 0 :size 15) + (eop uint8 :offset 15 :size 1) + (id uint16 :offset 32 :size 14) + (pre uint8 :offset 46 :size 1) + (prim gs-prim :offset 47 :size 11) + (flg gif-flag :offset 58 :size 2) + (nreg uint8 :offset 60 :size 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype gif-tag (uint128) + ((nloop uint16 :offset 0 :size 15) + (eop uint8 :offset 15 :size 1) + (id uint16 :offset 32 :size 14) + (pre uint8 :offset 46 :size 1) + (prim uint16 :offset 47 :size 11) + (flg gif-flag :offset 58 :size 2) + (nreg uint8 :offset 60 :size 4) + (regs0 gif-reg-id :offset 64 :size 4) + (regs1 gif-reg-id :offset 68 :size 4) + (regs2 gif-reg-id :offset 72 :size 4) + (regs3 gif-reg-id :offset 76 :size 4) + (regs4 gif-reg-id :offset 80 :size 4) + (regs5 gif-reg-id :offset 84 :size 4) + (regs6 gif-reg-id :offset 88 :size 4) + (regs7 gif-reg-id :offset 92 :size 4) + (regs8 gif-reg-id :offset 96 :size 4) + (regs9 gif-reg-id :offset 100 :size 4) + (regs10 gif-reg-id :offset 104 :size 4) + (regs11 gif-reg-id :offset 108 :size 4) + (regs12 gif-reg-id :offset 112 :size 4) + (regs13 gif-reg-id :offset 116 :size 4) + (regs14 gif-reg-id :offset 120 :size 4) + (regs15 gif-reg-id :offset 124 :size 4) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype gif-tag-regs (uint64) + ((regs0 gif-reg-id :offset 0 :size 4) + (regs1 gif-reg-id :offset 4 :size 4) + (regs2 gif-reg-id :offset 8 :size 4) + (regs3 gif-reg-id :offset 12 :size 4) + (regs4 gif-reg-id :offset 16 :size 4) + (regs5 gif-reg-id :offset 20 :size 4) + (regs6 gif-reg-id :offset 24 :size 4) + (regs7 gif-reg-id :offset 28 :size 4) + (regs8 gif-reg-id :offset 32 :size 4) + (regs9 gif-reg-id :offset 36 :size 4) + (regs10 gif-reg-id :offset 40 :size 4) + (regs11 gif-reg-id :offset 44 :size 4) + (regs12 gif-reg-id :offset 48 :size 4) + (regs13 gif-reg-id :offset 52 :size 4) + (regs14 gif-reg-id :offset 56 :size 4) + (regs15 gif-reg-id :offset 60 :size 4) + ) + ) + +(deftype gs-gif-tag (structure) + ((qword uint128 :offset-assert 0) + (tag gif-tag64 :offset 0) + (regs gif-tag-regs :offset 8) + (dword uint64 2 :offset 0) + (word uint32 4 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(defmethod inspect gif-tag ((obj gif-tag)) + (format #t "[~8x] gif-tag~%" obj) + (format #t "~Tnloop: ~4d~%" (-> obj nloop)) + (format #t "~Teop : ~4d~%" (-> obj eop)) + (format #t "~Tid : ~4d~%" (-> obj id)) + (format #t "~Tpre : ~4d~%" (-> obj pre)) + (format #t "~Tprim : ~4d~%" (-> obj prim)) + (format #t "~Tflg : ~4d~%" (-> obj flg)) + (format #t "~Tnreg : ~4d~%" (-> obj nreg)) + (format #t "~Tregs0 : ~4d~%" (-> obj regs0)) + (format #t "~Tregs1 : ~4d~%" (-> obj regs1)) + (format #t "~Tregs2 : ~4d~%" (-> obj regs2)) + (format #t "~Tregs3 : ~4d~%" (-> obj regs3)) + (format #t "~Tregs4 : ~4d~%" (-> obj regs4)) + (format #t "~Tregs5 : ~4d~%" (-> obj regs5)) + (format #t "~Tregs6 : ~4d~%" (-> obj regs6)) + (format #t "~Tregs7 : ~4d~%" (-> obj regs7)) + (format #t "~Tregs8 : ~4d~%" (-> obj regs8)) + (format #t "~Tregs9 : ~4d~%" (-> obj regs9)) + (format #t "~Tregs10: ~4d~%" (-> obj regs10)) + (format #t "~Tregs11: ~4d~%" (-> obj regs11)) + (format #t "~Tregs12: ~4d~%" (-> obj regs12)) + (format #t "~Tregs13: ~4d~%" (-> obj regs13)) + (format #t "~Tregs14: ~4d~%" (-> obj regs14)) + (the-as gif-tag (format #t "~Tregs15: ~4d~%" (-> obj regs15))) + ) + +(define *fog-color* (new 'static 'rgba :r #x80)) + +(deftype gif-packet (basic) + ((reg-count int32 :offset-assert 4) + (gif-tag gs-gif-tag :inline :offset-assert 16) + (gif-tag0 uint128 :offset 16) + (args uint64 1 :offset-assert 32) + ) + :method-count-assert 9 + :size-assert #x28 + :flag-assert #x900000028 + (:methods + (new (symbol type int) _type_ 0) + ) + ) + +(defmethod new gif-packet ((allocation symbol) (type-to-make type) (arg0 int)) + (object-new allocation type-to-make (the-as int (+ (-> type-to-make size) (* (+ arg0 -1) 8)))) + ) + +(defun open-gif-packet ((arg0 gif-packet)) + (set! (-> arg0 reg-count) 0) + (set! (-> arg0 gif-tag regs) (new 'static 'gif-tag-regs)) + arg0 + ) + +(defun add-reg-gif-packet ((arg0 gif-packet) (arg1 int) (arg2 int)) + (let ((v1-0 (-> arg0 gif-tag))) + (logior! (-> v1-0 regs) (ash arg1 (* (-> arg0 reg-count) 4))) + ) + (set! (-> (&-> arg0 args (-> arg0 reg-count)) 0) (the-as uint arg2)) + (+! (-> arg0 reg-count) 1) + (none) + ) + +(defun close-gif-packet ((arg0 gif-packet) (arg1 int)) + (set! (-> arg0 gif-tag tag) + (new 'static 'gif-tag64 :nloop #x1 :flg (gif-flag reg-list) :eop arg1 :nreg (-> arg0 reg-count)) + ) + arg0 + ) + +;; definition of type draw-context +(deftype draw-context (basic) + ((orgx int32 :offset-assert 4) + (orgy int32 :offset-assert 8) + (orgz int32 :offset-assert 12) + (width int32 :offset-assert 16) + (height int32 :offset-assert 20) + (color rgba 4 :offset-assert 24) ;; weird.. only first is used? + ) + :method-count-assert 9 + :size-assert #x28 + :flag-assert #x900000028 + (:methods + (new (symbol type int int int int rgba) _type_ 0) + ) + ) + +(defmethod new draw-context ((allocation symbol) (type-to-make type) (arg0 int) (arg1 int) (arg2 int) (arg3 int) (arg4 rgba)) + (let ((v0-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (set! (-> v0-0 orgx) arg0) + (set! (-> v0-0 orgy) arg1) + (set! (-> v0-0 orgz) #xffffff) + (set! (-> v0-0 width) arg2) + (set! (-> v0-0 height) arg3) + (set! (-> v0-0 color 0) arg4) + v0-0 + ) + ) + +(defun draw-context-set-xy ((arg0 draw-context) (arg1 int) (arg2 int)) + (set! (-> arg0 orgx) arg1) + (set! (-> arg0 orgy) arg2) + (none) + ) + +(deftype gs-packed-rgba (vector4w) + ((r int32 :offset 0) + (g int32 :offset 4) + (b int32 :offset 8) + (a int32 :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype gs-packed-xyzw (vector) + ((ix int32 :offset 0) + (iy int32 :offset 4) + (iz int32 :offset 8) + (iw int32 :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype gs-packed-stq (vector) + ((tex-s float :offset 0) + (tex-t float :offset 4) + (tex-q float :offset 8) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype gs-packed-uv (vector) + ((u int16 :offset 0) + (v int16 :offset 4) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype gs-packed-gt (structure) + ((stq gs-packed-stq :inline :offset 0) + (rgba gs-packed-rgba :inline :offset 16) + (xyzw gs-packed-xyzw :inline :offset 32) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype gs-packed-gt4 (structure) + ((data gs-packed-gt 4 :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #xc0 + :flag-assert #x9000000c0 + ) + diff --git a/goal_src/jak2/engine/gfx/hw/video-h.gc b/goal_src/jak2/engine/gfx/hw/video-h.gc index 74a8fd8b53..d3351ba2a1 100644 --- a/goal_src/jak2/engine/gfx/hw/video-h.gc +++ b/goal_src/jak2/engine/gfx/hw/video-h.gc @@ -5,3 +5,32 @@ ;; name in dgo: video-h ;; dgos: ENGINE, GAME +(deftype video-params (structure) + ((set-video-mode basic :offset-assert 0) + (reset-video-mode basic :offset-assert 4) + (display-fbp int32 :offset-assert 8) + (relative-x-scale float :offset 16) + (display-dx int32 :offset-assert 20) + (display-dy int32 :offset-assert 24) + (display-sy int32 :offset-assert 28) + (relative-x-scale-reciprical float :offset-assert 32) + (screen-pages-high int32 :offset-assert 36) + ) + :method-count-assert 9 + :size-assert #x28 + :flag-assert #x900000028 + ) + +(define *video-params* (new 'static 'video-params + :set-video-mode #f + :reset-video-mode #f + :display-fbp #xa4 + :relative-x-scale 1.0 + :display-dy 8 + :display-sy #xe0 + :relative-x-scale-reciprical 1.0 + :screen-pages-high 13 + ) + ) + + diff --git a/goal_src/jak2/engine/gfx/lights-h.gc b/goal_src/jak2/engine/gfx/lights-h.gc index 1dde389e91..d6c75ba680 100644 --- a/goal_src/jak2/engine/gfx/lights-h.gc +++ b/goal_src/jak2/engine/gfx/lights-h.gc @@ -5,3 +5,105 @@ ;; name in dgo: lights-h ;; dgos: ENGINE, GAME +(deftype vu-lights (structure) + ((direction vector 3 :inline :offset-assert 0) + (color vector 3 :inline :offset-assert 48) + (ambient vector :inline :offset-assert 96) + ) + :method-count-assert 9 + :size-assert #x70 + :flag-assert #x900000070 + ) + +(deftype light (structure) + ((direction vector :inline :offset-assert 0) + (color rgbaf :inline :offset-assert 16) + (extra vector :inline :offset-assert 32) + (level float :offset 32) + (luminance float :offset 40) + (priority float :offset 44) + (bytes uint8 4 :offset 36) + (mask uint16 :offset 36) + (palette-index int8 :offset 39) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype light-sphere (structure) + ((name basic :offset-assert 0) + (bsphere vector :inline :offset-assert 16) + (direction vector :inline :offset-assert 32) + (color vector :inline :offset-assert 48) + (decay-start float :offset 4) + (ambient-point-ratio float :offset 8) + (brightness float :offset 12) + (bytes uint8 4 :offset 60) + (mask uint16 :offset 60) + (palette-index int8 :offset 63) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + +(deftype light-hash-bucket (structure) + ((index uint16 :offset-assert 0) + (count uint16 :offset-assert 2) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype light-hash (basic) + ((num-lights uint16 :offset-assert 4) + (num-indices uint16 :offset-assert 6) + (num-buckets uint16 :offset-assert 8) + (bucket-step uint16 2 :offset-assert 10) + (base-trans vector :inline :offset-assert 16) + (axis-scale vector :inline :offset-assert 32) + (dimension-array vector4w :inline :offset-assert 48) + (bucket-array uint32 :offset-assert 64) + (index-array uint32 :offset-assert 68) + (light-sphere-array uint32 :offset-assert 72) + ) + :method-count-assert 9 + :size-assert #x4c + :flag-assert #x90000004c + ) + +(deftype light-hash-work (structure) + ((ones vector4w :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(define *light-hash* (the-as light-hash-work #f)) + +(defmethod print light ((obj light)) + (format + #t + "# obj extra x) + (-> obj direction x) + (-> obj direction y) + (-> obj direction z) + ) + (format #t "~F ~F ~F @ #x~X>" (-> obj color x) (-> obj color y) (-> obj color z) obj) + obj + ) + +(deftype light-group (structure) + ((dir0 light :inline :offset-assert 0) + (dir1 light :inline :offset-assert 48) + (dir2 light :inline :offset-assert 96) + (ambi light :inline :offset-assert 144) + ) + :method-count-assert 9 + :size-assert #xc0 + :flag-assert #x9000000c0 + ) diff --git a/goal_src/jak2/engine/gfx/math-camera-h.gc b/goal_src/jak2/engine/gfx/math-camera-h.gc index f7cd668138..00e4dd90ce 100644 --- a/goal_src/jak2/engine/gfx/math-camera-h.gc +++ b/goal_src/jak2/engine/gfx/math-camera-h.gc @@ -5,3 +5,108 @@ ;; name in dgo: math-camera-h ;; dgos: ENGINE, GAME +(deftype vis-gif-tag (structure) + ((fog0 uint32 :offset-assert 0) + (strip uint32 :offset-assert 4) + (regs uint32 :offset-assert 8) + (fan uint32 :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype cull-info (structure) + ((x-fact float :offset-assert 0) + (y-fact float :offset-assert 4) + (z-fact float :offset-assert 8) + (cam-radius float :offset-assert 12) + (cam-x float :offset-assert 16) + (cam-y float :offset-assert 20) + (xz-dir-ax float :offset-assert 24) + (xz-dir-az float :offset-assert 28) + (xz-dir-bx float :offset-assert 32) + (xz-dir-bz float :offset-assert 36) + (xz-cross-ab float :offset-assert 40) + (yz-dir-ay float :offset-assert 44) + (yz-dir-az float :offset-assert 48) + (yz-dir-by float :offset-assert 52) + (yz-dir-bz float :offset-assert 56) + (yz-cross-ab float :offset-assert 60) + ) + :allow-misaligned + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + + +(deftype math-camera (basic) + ((d meters :offset-assert 4) + (f meters :offset-assert 8) + (fov degrees :offset-assert 12) + (x-ratio float :offset-assert 16) + (y-ratio float :offset-assert 20) + (x-pix float :offset-assert 24) + (x-clip float :offset-assert 28) + (x-clip-ratio-in float :offset-assert 32) + (x-clip-ratio-over float :offset-assert 36) + (y-pix float :offset-assert 40) + (y-clip float :offset-assert 44) + (y-clip-ratio-in float :offset-assert 48) + (y-clip-ratio-over float :offset-assert 52) + (cull-info cull-info :inline :offset-assert 56) + (fog-start meters :offset-assert 120) + (fog-end meters :offset-assert 124) + (fog-max float :offset-assert 128) + (fog-min float :offset-assert 132) + (reset int32 :offset-assert 136) + (smooth-step float :offset-assert 140) + (smooth-t float :offset-assert 144) + (perspective matrix :inline :offset-assert 160) + (isometric matrix :inline :offset-assert 224) + (sprite-2d matrix :inline :offset-assert 288) + (sprite-2d-hvdf vector :inline :offset-assert 352) + (camera-rot matrix :inline :offset-assert 368) + (inv-camera-rot matrix :inline :offset-assert 432) + (inv-camera-rot-smooth matrix :inline :offset-assert 496) + (inv-camera-rot-smooth-from quaternion :inline :offset-assert 560) + (camera-temp matrix :inline :offset-assert 576) + (prev-camera-temp matrix :inline :offset-assert 640) + (prev-inv-camera-rot matrix :inline :offset-assert 704) + (prev-trans vector :inline :offset-assert 768) + (hmge-scale vector :inline :offset-assert 784) + (inv-hmge-scale vector :inline :offset-assert 800) + (hvdf-off vector :inline :offset-assert 816) + (guard vector :inline :offset-assert 832) + (vis-gifs vis-gif-tag 4 :inline :offset-assert 848) + (giftex uint128 :offset 848) + (gifgr uint128 :offset 864) + (giftex-trans uint128 :offset 880) + (gifgr-trans uint128 :offset 896) + (pfog0 float :offset-assert 912) + (pfog1 float :offset-assert 916) + (trans vector :inline :offset-assert 928) + (plane plane 4 :inline :offset-assert 944) + (guard-plane plane 4 :inline :offset-assert 1008) + (shrub-mat matrix :inline :offset-assert 1072) + (quat-other quaternion :inline :offset-assert 1136) + (trans-other vector :inline :offset-assert 1152) + (shrub-mat-other matrix :inline :offset-assert 1168) + (camera-temp-other matrix :inline :offset-assert 1232) + (camera-rot-other matrix :inline :offset-assert 1296) + (inv-camera-rot-other matrix :inline :offset-assert 1360) + (plane-other plane 4 :inline :offset-assert 1424) + (guard-plane-other plane 4 :inline :offset-assert 1488) + (mirror-trans vector :inline :offset-assert 1552) + (mirror-normal vector :inline :offset-assert 1568) + (fov-correction-factor float :offset-assert 1584) + ) + :method-count-assert 9 + :size-assert #x634 + :flag-assert #x900000634 + ) + + + + diff --git a/goal_src/jak2/engine/gfx/math-camera.gc b/goal_src/jak2/engine/gfx/math-camera.gc index a6a7152b92..01b73c8ade 100644 --- a/goal_src/jak2/engine/gfx/math-camera.gc +++ b/goal_src/jak2/engine/gfx/math-camera.gc @@ -5,3 +5,633 @@ ;; name in dgo: math-camera ;; dgos: ENGINE, GAME +(deftype fog-corrector (structure) + ((fog-end float :offset-assert 0) + (fog-start float :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(defun fog-corrector-setup ((arg0 fog-corrector) (arg1 math-camera)) + (set! (-> arg0 fog-end) (* (-> arg1 fog-end) (-> arg1 fov-correction-factor))) + (set! (-> arg0 fog-start) (* (-> arg1 fog-start) (-> arg1 fov-correction-factor))) + (none) + ) + +(define *math-camera-fog-correction* (new 'global 'fog-corrector)) + +(define-extern sprite-distorter-generate-tables (function none)) + +(defun update-math-camera ((arg0 math-camera) (arg1 symbol) (arg2 symbol) (arg3 float)) + (local-vars (sv-16 float)) + (set! (-> arg0 x-ratio) (tan (* 0.5 arg3))) + (if (= arg2 'aspect4x3) + (set! (-> arg0 y-ratio) (* 0.75 (-> arg0 x-ratio))) + (set! (-> arg0 y-ratio) (* 0.5625 (-> arg0 x-ratio))) + ) + (let ((f1-3 (-> arg0 x-ratio)) + (f0-7 (-> arg0 y-ratio)) + (v1-6 (-> arg0 cull-info)) + ) + (/ (+ 1.0 (* 4.0 f1-3 f1-3)) (+ 1.0 (* f1-3 f1-3))) + (let ((f2-5 (/ (+ 1.0 (* 4.0 f0-7 f0-7)) (+ 1.0 (* f0-7 f0-7))))) + (set! (-> v1-6 x-fact) (/ (+ 1.0 (* 4.0 f1-3 f1-3)) (* f1-3 (sqrtf (+ 1.0 (* 16.0 f1-3 f1-3)))))) + (set! (-> v1-6 y-fact) (/ (+ 1.0 (* 4.0 f0-7 f0-7)) (* f0-7 (sqrtf (+ 1.0 (* 16.0 f0-7 f0-7)))))) + (set! (-> v1-6 z-fact) (sqrtf (+ (* (+ -4.0 f2-5) (+ -4.0 f2-5) f0-7 f0-7) (* (+ -1.0 f2-5) (+ -1.0 f2-5))))) + ) + (let* ((f2-11 (* f1-3 (-> arg0 d))) + (f1-5 (* f0-7 (-> arg0 d))) + (f0-10 (+ (* f2-11 f2-11) (* f1-5 f1-5))) + (f1-8 (-> arg0 d)) + ) + (set! (-> v1-6 cam-radius) (sqrtf (+ f0-10 (* f1-8 f1-8)))) + ) + (let* ((f1-12 (* (-> arg0 d) (-> arg0 x-ratio))) + (f0-14 (-> arg0 d)) + (f2-13 (* 4.0 f1-12)) + (f3-21 (-> arg0 d)) + ) + (let ((f4-21 (/ 1.0 (sqrtf (+ (* f1-12 f1-12) (* f0-14 f0-14))))) + (f5-11 (/ 1.0 (sqrtf (+ (* f2-13 f2-13) (* f3-21 f3-21))))) + ) + (set! (-> v1-6 xz-dir-ax) (* f1-12 f4-21)) + (set! (-> v1-6 xz-dir-az) (* f0-14 f4-21)) + (set! (-> v1-6 xz-dir-bx) (* f2-13 f5-11)) + (set! (-> v1-6 xz-dir-bz) (* f3-21 f5-11)) + ) + (set! (-> v1-6 xz-cross-ab) (- (* f1-12 f3-21) (* f0-14 f2-13))) + ) + (let* ((f1-15 (* (-> arg0 d) (-> arg0 y-ratio))) + (f0-18 (-> arg0 d)) + (f2-15 (* 4.0 f1-15)) + (f3-22 (-> arg0 d)) + ) + (let ((f4-26 (/ 1.0 (sqrtf (+ (* f1-15 f1-15) (* f0-18 f0-18))))) + (f5-16 (/ 1.0 (sqrtf (+ (* f2-15 f2-15) (* f3-22 f3-22))))) + ) + (set! (-> v1-6 yz-dir-ay) (* f1-15 f4-26)) + (set! (-> v1-6 yz-dir-az) (* f0-18 f4-26)) + (set! (-> v1-6 yz-dir-by) (* f2-15 f5-16)) + (set! (-> v1-6 yz-dir-bz) (* f3-22 f5-16)) + ) + (set! (-> v1-6 yz-cross-ab) (- (* f1-15 f3-22) (* f0-18 f2-15))) + ) + ) + (fog-corrector-setup *math-camera-fog-correction* arg0) + (matrix-identity! (-> arg0 camera-rot)) + (let ((f0-21 100.0) + (f2-16 16760631.0) + ) + 16777115.0 + (let ((f30-0 (/ (* (-> arg0 d) (- (-> arg0 fog-min) (-> arg0 fog-max))) + (- (-> *math-camera-fog-correction* fog-end) (-> *math-camera-fog-correction* fog-start)) + ) + ) + (f1-21 (* -0.5 (- f2-16 f0-21))) + ) + (let ((f4-34 (/ f1-21 (* (-> arg0 d) (- (-> arg0 f) (-> arg0 d))))) + (f3-30 (-> arg0 fov-correction-factor)) + ) + (set! (-> arg0 perspective data 0) (* f3-30 (- (/ (-> arg0 x-pix) (* (-> arg0 x-ratio) (-> arg0 d)))))) + (set! (-> arg0 perspective data 5) (* f3-30 (- (/ (-> arg0 y-pix) (* (-> arg0 y-ratio) (-> arg0 d)))))) + (set! (-> arg0 perspective data 10) (* f3-30 (+ (-> arg0 f) (-> arg0 d)) f4-34)) + (set! (-> arg0 perspective data 11) (* (/ f3-30 (-> arg0 d)) f30-0)) + (set! (-> arg0 perspective trans z) (* -2.0 f4-34 (-> arg0 f) (-> arg0 d) f3-30)) + ) + (let ((f24-0 2048.0) + (f26-0 2048.0) + (f28-0 (/ (- (* (-> *math-camera-fog-correction* fog-end) (-> arg0 fog-max)) + (* (-> *math-camera-fog-correction* fog-start) (-> arg0 fog-min)) + ) + (- (-> *math-camera-fog-correction* fog-end) (-> *math-camera-fog-correction* fog-start)) + ) + ) + ) + (let ((f22-0 (* 0.5 (+ f2-16 f0-21)))) + (set! (-> arg0 hmge-scale x) (/ 1.0 (-> arg0 x-clip))) + (set! (-> arg0 hmge-scale y) (/ 1.0 (-> arg0 y-clip))) + (set! (-> arg0 hmge-scale z) (/ 1.0 f1-21)) + (set! (-> arg0 hmge-scale w) (/ 1.0 f30-0)) + (set! (-> arg0 inv-hmge-scale x) (-> arg0 x-clip)) + (set! (-> arg0 inv-hmge-scale y) (-> arg0 y-clip)) + (set! (-> arg0 inv-hmge-scale z) f1-21) + (set! (-> arg0 inv-hmge-scale w) f30-0) + (cond + ((or (zero? *screen-shot-work*) (= (-> *screen-shot-work* count) -1)) + (set! (-> arg0 hvdf-off x) f24-0) + (set! (-> arg0 hvdf-off y) f26-0) + ) + (else + (let* ((v1-32 (-> *screen-shot-work* count)) + (a0-36 (-> *screen-shot-work* size)) + (f0-34 (the float a0-36)) + (f20-0 (/ (the float (mod v1-32 a0-36)) f0-34)) + ) + (set! sv-16 (/ (the float (/ v1-32 a0-36)) f0-34)) + (format 0 "~f ~f~%" f20-0 sv-16) + (set! (-> arg0 hvdf-off x) (- f24-0 f20-0)) + ) + (set! (-> arg0 hvdf-off y) (- f26-0 sv-16)) + ) + ) + (set! (-> arg0 hvdf-off z) f22-0) + (set! (-> arg0 hvdf-off w) f28-0) + (set! (-> arg0 guard x) (/ (-> arg0 x-clip) (-> arg0 x-pix))) + (set! (-> arg0 guard y) (/ (-> arg0 y-clip) (-> arg0 y-pix))) + (set! (-> arg0 guard z) 1.0) + (set! (-> arg0 guard w) 1.0) + (set! (-> arg0 isometric trans z) (- 16777215.0 f22-0)) + ;; PC HACK! + ;; for whatever reason, the font render ends up computing a depth #x1000000 instead of + ;; #xffffffff, which overflows the 24-bit z buffer. + ;; cheating this by 1 bit seems to fix it. + (#when PC_PORT + ;; #x4b002032 -> #x4b002031 + (set! (-> arg0 isometric vector 3 z) (the-as float (- (the-as int (-> arg0 isometric vector 3 z)) 1))) + ) + + ) + (set! (-> arg0 isometric trans w) f30-0) + (let ((f1-28 (-> arg0 perspective data 0)) + (f2-19 (-> arg0 perspective data 5)) + (f0-48 (* -1.9996 (-> arg0 perspective data 0))) + ) + (let ((v1-39 (-> arg0 sprite-2d))) + (set! (-> v1-39 data 0) f0-48) + (set! (-> v1-39 data 1) 0.0) + (set! (-> v1-39 data 2) 0.0) + (set! (-> v1-39 data 3) 0.0) + ) + (let ((v1-40 (&-> arg0 sprite-2d data 4))) + (set! (-> v1-40 0) 0.0) + (set! (-> v1-40 1) (- (* (/ f2-19 f1-28) f0-48))) + (set! (-> v1-40 2) 0.0) + (set! (-> v1-40 3) 0.0) + ) + (let ((v1-41 (&-> arg0 sprite-2d data 8))) + (set! (-> v1-41 0) 0.0) + (set! (-> v1-41 1) 0.0) + (set! (-> v1-41 2) (- f0-48)) + (set! (-> v1-41 3) 0.0) + ) + (set-vector! (-> arg0 sprite-2d trans) 0.0 0.0 (* 500000000.0 f0-48) (* 60.0 f0-48 (-> arg0 pfog0))) + ) + (set! (-> arg0 sprite-2d-hvdf quad) (-> arg0 hvdf-off quad)) + (set! (-> arg0 sprite-2d-hvdf x) 2048.0) + (set! (-> arg0 sprite-2d-hvdf y) 2048.0) + (set! (-> arg0 sprite-2d-hvdf z) (-> arg0 hvdf-off z)) + (set! (-> arg0 pfog0) f30-0) + (set! (-> arg0 pfog1) f28-0) + ) + ) + ) + 0 + #| + (make-u128 0 (shl #x301ec000 32)) + (make-u128 0 (shl #x303ec000 32)) + (let ((v1-54 (-> arg0 pfog0))) + (let ((a0-42 (-> arg0 vis-gifs))) + (set! (-> a0-42 0 fog0) (the-as uint v1-54)) + (set! (-> a0-42 0 strip) (the-as uint #x301e4000)) + (set! (-> a0-42 0 regs) (the-as uint 1042)) + (set! (-> a0-42 0 fan) (the-as uint #x301ec000)) + ) + (let ((a0-43 (&-> arg0 gifgr))) + (s.w! a0-43 v1-54) + (let ((a1-9 (make-u128 0 (shl #x20164000 32)))) + (s.w! (+ a0-43 4) a1-9) + ) + (let ((a1-10 65)) + (s.w! (+ a0-43 8) a1-10) + ) + (let ((a1-11 #x301ec000)) + (s.w! (+ a0-43 12) a1-11) + ) + ) + (let ((a0-44 (-> arg0 vis-gifs))) + (set! (-> a0-44 0 fog0) (the-as uint v1-54)) + (set! (-> a0-44 0 strip) (the-as uint #x303e4000)) + (set! (-> a0-44 0 regs) (the-as uint 1042)) + (set! (-> a0-44 0 fan) (the-as uint #x303ec000)) + ) + (let ((a0-45 (-> arg0 vis-gifs))) + (set! (-> a0-45 0 fog0) (the-as uint v1-54)) + (set! (-> a0-45 0 strip) (the-as uint #x303e4000)) + (set! (-> a0-45 0 regs) (the-as uint 1042)) + (set! (-> a0-45 0 fan) (the-as uint #x303ec000)) + ) + ) + |# + (if (nonzero? sprite-distorter-generate-tables) + (sprite-distorter-generate-tables) + ) + arg0 + ) + +(defmethod new math-camera ((allocation symbol) (type-to-make type)) + (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (set! (-> gp-0 d) 1024.0) + (set! (-> gp-0 f) 40960000.0) + (set! (-> gp-0 fov) 11650.845) + (set! (-> gp-0 x-pix) 256.0) + (set! (-> gp-0 x-clip) 1024.0) + (set! (-> gp-0 y-pix) 112.0) + (set! (-> gp-0 y-clip) 448.0) + (set! (-> gp-0 fog-start) 40960.0) + (set! (-> gp-0 fog-end) 819200.0) + (set! (-> gp-0 fog-max) 255.0) + (set! (-> gp-0 fog-min) 150.0) + (matrix-identity! (-> gp-0 inv-camera-rot)) + (matrix-identity! (-> gp-0 camera-rot)) + (vector-reset! (-> gp-0 trans)) + (quaternion-identity! (-> gp-0 quat-other)) + (set-vector! (-> gp-0 trans-other) 0.0 0.0 0.0 1.0) + (matrix-identity! (-> gp-0 inv-camera-rot-other)) + (matrix-identity! (-> gp-0 camera-rot-other)) + (matrix-identity! (-> gp-0 camera-temp-other)) + (set! (-> gp-0 isometric data 0) 1.0) + (set! (-> gp-0 isometric data 5) 0.5) + (set! (-> gp-0 isometric data 10) -1.0) + (set! (-> gp-0 reset) 1) + (set! (-> gp-0 smooth-step) 0.0) + (set! (-> gp-0 smooth-t) 0.0) + (update-math-camera gp-0 'ntsc 'aspect4x3 (-> gp-0 fov)) + ) + ) + +(define *math-camera* (new 'global 'math-camera)) + +(defun math-cam-start-smoothing ((arg0 float) (arg1 float)) + (set! (-> *math-camera* smooth-step) (/ 1.0 arg0)) + (set! (-> *math-camera* smooth-t) arg1) + (matrix->quaternion (-> *math-camera* inv-camera-rot-smooth-from) (-> *math-camera* inv-camera-rot-smooth)) + ) + +#| +(defun move-target-from-pad ((arg0 transform) (arg1 int)) + (let ((s4-0 (new-stack-vector0))) + (set! (-> s4-0 x) (the-as float (gpr->fpr (cond + ((cpad-hold? arg1 circle) + -1029701632 + ) + ((cpad-hold? arg1 square) + #x42a00000 + ) + (else + 0 + ) + ) + ) + ) + ) + (set! (-> s4-0 y) 0.0) + (set! (-> s4-0 z) (the-as float (gpr->fpr (cond + ((cpad-hold? arg1 down) + -1029701632 + ) + ((cpad-hold? arg1 up) + #x42a00000 + ) + (else + 0 + ) + ) + ) + ) + ) + (set! (-> s4-0 w) 1.0) + (let ((a0-5 (new-stack-vector0)) + (s3-0 (new-stack-matrix0)) + ) + (vector-negate! a0-5 (-> arg0 rot)) + (matrix-rotate-zyx! s3-0 (-> arg0 rot)) + (vector-matrix*! s4-0 s4-0 s3-0) + ) + (vector+! (-> arg0 trans) (-> arg0 trans) s4-0) + ) + (set! (-> arg0 trans w) 1.0) + (if (cpad-hold? arg1 r1) + (set! (-> arg0 trans y) (+ 80.0 (-> arg0 trans y))) + ) + (if (cpad-hold? arg1 r2) + (set! (-> arg0 trans y) (+ -80.0 (-> arg0 trans y))) + ) + (if (cpad-hold? arg1 x) + (set! (-> arg0 rot x) (+ 546.13336 (-> arg0 rot x))) + ) + (if (cpad-hold? arg1 triangle) + (set! (-> arg0 rot x) (+ -546.13336 (-> arg0 rot x))) + ) + (if (cpad-hold? arg1 left) + (set! (-> arg0 rot y) (+ 546.13336 (-> arg0 rot y))) + ) + (if (cpad-hold? arg1 right) + (set! (-> arg0 rot y) (+ -546.13336 (-> arg0 rot y))) + ) + arg0 + ) + |# + +(defun transform-point-vector! ((arg0 vector) (arg1 vector)) + "Apply camera transformation to a point. Return true if it is visible or not. + This returns the point in GS coords, but as float instead of int, so it's + not really useful. See transform-point-qword! for more details" + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf23 :class vf) + (vf24 :class vf) + (vf25 :class vf) + (vf26 :class vf) + (vf27 :class vf) + (vf28 :class vf) + (vf29 :class vf) + (vf30 :class vf) + (vf31 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 0)) + ) + (.lvf vf24 (&-> *math-camera* camera-temp vector 0 quad)) + (.lvf vf25 (&-> *math-camera* camera-temp vector 1 quad)) + (.lvf vf26 (&-> *math-camera* camera-temp vector 2 quad)) + (.lvf vf27 (&-> *math-camera* camera-temp vector 3 quad)) + (.lvf vf29 (&-> *math-camera* hmge-scale quad)) + (.lvf vf30 (&-> *math-camera* hvdf-off quad)) + (.lvf vf28 (&-> arg1 quad)) + (.mul.x.vf acc vf24 vf28) + (.add.mul.y.vf acc vf25 vf28 acc) + (.add.mul.z.vf acc vf26 vf28 acc) + (.add.mul.w.vf vf28 vf27 vf0 acc) + (.add.w.vf vf23 vf0 vf0) + (.mul.vf vf31 vf28 vf29) + ;;(TODO.VCLIP vf31 vf31) + (let ((clip (vu-clip vf31 0))) + (.div.vf Q vf0 vf31 :fsf #b11 :ftf #b11) + (.wait.vf) + ;;(.cfc2.i v1-7 Clipping) + (.mul.vf vf28 vf28 Q :mask #b111) + (.mul.vf vf23 vf23 Q) + (.add.vf vf28 vf28 vf30) + (.max.x.vf vf28 vf28 vf0 :mask #b1000) + (.svf (&-> arg0 quad) vf28) + (zero? (logand clip 63)) + ) + ) + ) + +(defun transform-point-qword! ((arg0 vector4w) (arg1 vector)) + "Apply camera transformation to point, returning fixed point 28.4 position + that can be given to the GS directly." + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf23 :class vf) + (vf24 :class vf) + (vf25 :class vf) + (vf26 :class vf) + (vf27 :class vf) + (vf28 :class vf) + (vf29 :class vf) + (vf30 :class vf) + (vf31 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 0)) + ) + + ;; this camera matrix has both the projection and camera translation/rotation + (.lvf vf24 (&-> *math-camera* camera-temp vector 0 quad)) + (.lvf vf25 (&-> *math-camera* camera-temp vector 1 quad)) + (.lvf vf26 (&-> *math-camera* camera-temp vector 2 quad)) + (.lvf vf27 (&-> *math-camera* camera-temp vector 3 quad)) + + ;; scaling + (.lvf vf29 (&-> *math-camera* hmge-scale quad)) + + ;; offset + (.lvf vf30 (&-> *math-camera* hvdf-off quad)) + + ;; input point + (.lvf vf28 (&-> arg1 quad)) + + ;; matrix multiply, result in vf28 + (.mul.x.vf acc vf24 vf28) + (.add.mul.y.vf acc vf25 vf28 acc) + (.add.mul.z.vf acc vf26 vf28 acc) + (.add.mul.w.vf vf28 vf27 vf0 acc) + + + (.add.w.vf vf23 vf0 vf0) ;; set w = 1.0 + + ;; apply hmge scaling. the result of this multiply sets clipping flags appropriately + (.mul.vf vf31 vf28 vf29) ;; scale. + ;;(TODO.VCLIP vf31 vf31) + (let ((clip (vu-clip vf31 0))) ;; clip! + + ;; perspective divide + (.div.vf Q vf0 vf31 :fsf #b11 :ftf #b11) + (.wait.vf) + ;;(.cfc2.i v1-7 Clipping) + ;; perspective + (.mul.vf vf28 vf28 Q :mask #b111) + ;; compute scale factor (w was 1.0) + (.mul.vf vf23 vf23 Q) + ;; apply hvdf offsets + (.add.vf vf28 vf28 vf30) + ;; saturate fog + (.max.x.vf vf28 vf28 vf0 :mask #b1000) + ;; convert to GS fixed point + (vftoi4.xyzw vf28 vf28) + ;; store result! + (.svf (&-> arg0 quad) vf28) + ;; return result of clipping. + (zero? (logand clip 63)) + ) + ) + ) + +(defun transform-point-vector-scale! ((arg0 vector) (arg1 vector)) + "Similar to transform-point-qword! but returns the scale factor instead." + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf23 :class vf) + (vf24 :class vf) + (vf25 :class vf) + (vf26 :class vf) + (vf27 :class vf) + (vf28 :class vf) + (vf29 :class vf) + (vf30 :class vf) + (vf31 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 0)) + ) + (.lvf vf24 (&-> *math-camera* camera-temp vector 0 quad)) + (.lvf vf25 (&-> *math-camera* camera-temp vector 1 quad)) + (.lvf vf26 (&-> *math-camera* camera-temp vector 2 quad)) + (.lvf vf27 (&-> *math-camera* camera-temp vector 3 quad)) + (.lvf vf29 (&-> *math-camera* hmge-scale quad)) + (.lvf vf30 (&-> *math-camera* hvdf-off quad)) + (.lvf vf28 (&-> arg1 quad)) + (.mul.x.vf acc vf24 vf28) + (.add.mul.y.vf acc vf25 vf28 acc) + (.add.mul.z.vf acc vf26 vf28 acc) + (.add.mul.w.vf vf28 vf27 vf0 acc) + (.add.w.vf vf23 vf0 vf0) + (.mul.vf vf31 vf28 vf29) + ;;(TODO.VCLIP vf31 vf31) clip result was unused + (.div.vf Q vf0 vf31 :fsf #b11 :ftf #b11) + (.wait.vf) + ;;(.cfc2.i v1-7 Clipping) + (.mul.vf vf28 vf28 Q :mask #b111) + (.mul.vf vf23 vf23 Q) + (.add.vf vf28 vf28 vf30) + (.max.x.vf vf28 vf28 vf0 :mask #b1000) + (.svf (&-> arg0 quad) vf28) + ;;(let ((a0-2 (zero? (logand v1-7 63)))) + ;; ) + (.mov v0-0 vf23) + v0-0 + ) + ) + +(defun reverse-transform-point! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 vector)) + (let* ((v1-1 (-> *math-camera* perspective)) + (s2-0 (-> *math-camera* camera-rot)) + (f30-0 (* (/ (-> v1-1 data 11) (-> v1-1 data 0)) (-> *math-camera* hmge-scale w))) + (f28-0 (* (/ (-> v1-1 data 11) (-> v1-1 data 5)) (-> *math-camera* hmge-scale w))) + (s4-0 (vector-rotate*! (new 'stack-no-clear 'vector) arg2 s2-0)) + (v1-3 (vector-matrix*! (new 'stack-no-clear 'vector) arg1 s2-0)) + (f0-8 (/ (+ (* (-> s4-0 x) (-> v1-3 x)) (* (-> s4-0 y) (-> v1-3 y)) (* (-> s4-0 z) (-> v1-3 z))) + (+ (* (-> s4-0 x) (-> arg3 x) f30-0) (* (-> s4-0 y) (-> arg3 y) f28-0) (-> s4-0 z)) + ) + ) + (f1-16 (* (-> arg3 x) f0-8 f30-0)) + (f2-9 (* (-> arg3 y) f0-8 f28-0)) + (t9-2 vector-matrix*!) + (a0-5 arg0) + (a1-3 (new 'stack-no-clear 'vector)) + ) + (set! (-> a1-3 x) f1-16) + (set! (-> a1-3 y) f2-9) + (set! (-> a1-3 z) f0-8) + (set! (-> a1-3 w) 1.0) + (t9-2 a0-5 a1-3 (-> *math-camera* inv-camera-rot)) + ) + (none) + ) + + +(defun init-for-transform ((arg0 matrix)) + "Sets up VU0 registers with camera info. + This is probably a very old function and it's only used by jungle mirrors. + It stashes some data in vector float registers that must be there before calling transform-float-point." + (rlet ((vf1 :class vf) + (vf17 :class vf) + (vf18 :class vf) + (vf19 :class vf) + (vf2 :class vf) + (vf23 :class vf) + (vf24 :class vf) + (vf25 :class vf) + (vf26 :class vf) + (vf27 :class vf) + (vf28 :class vf) + (vf29 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf6 :class vf) + (vf7 :class vf) + (vf8 :class vf) + (vf9 :class vf) + ) + (let ((gp-0 (new-stack-matrix0)) + (s5-0 (new-stack-matrix0)) + (s4-0 (new 'stack 'vector4s-3)) + (s3-0 (new-stack-vector0)) + (s2-0 (new 'stack 'vector4s-3)) + ) + (matrix*! s5-0 arg0 (-> *math-camera* camera-temp)) + (matrix-3x3-inverse-transpose! gp-0 arg0) + (let ((v1-3 s3-0)) + (set! (-> v1-3 x) 0.4) + (set! (-> v1-3 y) 0.4) + (set! (-> v1-3 z) 0.4) + (set! (-> v1-3 w) 1.0) + ) + (let ((v1-4 (-> s4-0 data))) + (set! (-> v1-4 0) 1.0) + (set! (-> v1-4 1) 1.0) + (set! (-> v1-4 2) 1.0) + (set! (-> v1-4 3) 1.0) + ) + (let ((v1-5 (&-> s4-0 data 4))) + (set! (-> v1-5 0) 0.0) + (set! (-> v1-5 1) 0.0) + (set! (-> v1-5 2) 0.0) + (set! (-> v1-5 3) 1.0) + ) + (let ((v1-6 (&-> s4-0 data 8))) + (set! (-> v1-6 0) 0.0) + (set! (-> v1-6 1) 0.0) + (set! (-> v1-6 2) 0.0) + (set! (-> v1-6 3) 1.0) + ) + (let ((v1-7 (-> s2-0 data))) + (set! (-> v1-7 0) 1.0) + (set! (-> v1-7 1) 0.0) + (set! (-> v1-7 2) 0.0) + (set! (-> v1-7 3) 1.0) + ) + (let ((v1-8 (&-> s2-0 data 4))) + (set! (-> v1-8 0) 0.0) + (set! (-> v1-8 1) 1.0) + (set! (-> v1-8 2) 0.0) + (set! (-> v1-8 3) 1.0) + ) + (let ((v1-9 (&-> s2-0 data 8))) + (set! (-> v1-9 0) 0.0) + (set! (-> v1-9 1) 0.0) + (set! (-> v1-9 2) 1.0) + (set! (-> v1-9 3) 1.0) + ) + (.lvf vf7 (&-> *math-camera* hmge-scale quad)) + (.lvf vf8 (&-> *math-camera* hvdf-off quad)) + (.lvf vf9 (&-> *math-camera* giftex)) + (let ((v1-13 255)) + (.mov vf6 v1-13) + ) + ;;(.mov v1-14 vf6) + (.itof.vf vf6 vf6) + (.svf (&-> *transform-regs* vf7) vf7) + (.svf (&-> *transform-regs* vf8) vf8) + (.svf (&-> *transform-regs* vf9) vf9) + (.svf (&-> *transform-regs* vf6) vf6) + (set! (-> *transform-regs* vf1) (-> s5-0 vector 0 quad)) + (set! (-> *transform-regs* vf2) (-> s5-0 vector 1 quad)) + (set! (-> *transform-regs* vf3) (-> s5-0 vector 2 quad)) + (set! (-> *transform-regs* vf4) (-> s5-0 vector 3 quad)) + (set! (-> *transform-regs* vf17) (-> gp-0 vector 0 quad)) + (set! (-> *transform-regs* vf18) (-> gp-0 vector 1 quad)) + (set! (-> *transform-regs* vf19) (-> gp-0 vector 2 quad)) + (set! (-> *transform-regs* vf23) (-> s2-0 quad 0)) + (set! (-> *transform-regs* vf24) (-> s2-0 quad 1)) + (set! (-> *transform-regs* vf25) (-> s2-0 quad 2)) + + (set! (-> *transform-regs* vf27) (-> s4-0 quad 0)) + (set! (-> *transform-regs* vf28) (-> s4-0 quad 1)) + (set! (-> *transform-regs* vf29) (-> s4-0 quad 2)) + (set! (-> *transform-regs* vf26) (-> s3-0 quad)) + + ) + (none) + ) + ) + + diff --git a/goal_src/jak2/engine/gfx/mood/mood-h.gc b/goal_src/jak2/engine/gfx/mood/mood-h.gc index 97341b63ef..e402368d32 100644 --- a/goal_src/jak2/engine/gfx/mood/mood-h.gc +++ b/goal_src/jak2/engine/gfx/mood/mood-h.gc @@ -5,3 +5,242 @@ ;; name in dgo: mood-h ;; dgos: ENGINE, GAME +(deftype mood-channel (structure) + ((data float 24 :offset-assert 0) + (vecs vector4 6 :inline :offset 0) + ) + :method-count-assert 9 + :size-assert #x60 + :flag-assert #x900000060 + ) + +(deftype mood-channel-group (structure) + ((data mood-channel 4 :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x180 + :flag-assert #x900000180 + ) + +(deftype mood-fog (structure) + ((fog-color vector :inline :offset-assert 0) + (fog-dists vector :inline :offset-assert 16) + (fog-start meters :offset 16) + (fog-end meters :offset 20) + (fog-max float :offset 24) + (fog-min float :offset 28) + (erase-color vector :inline :offset-assert 32) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype mood-fog-table (structure) + ((data mood-fog 8 :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x180 + :flag-assert #x900000180 + ) + +(deftype mood-color (structure) + ((lgt-color vector :inline :offset-assert 0) + (amb-color vector :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(deftype mood-direction-table (structure) + ((data vector 4 :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + +(deftype mood-color-table (structure) + ((data mood-color 8 :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x100 + :flag-assert #x900000100 + ) + +(deftype mood-sky-table (structure) + ((data vector 8 :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x80 + :flag-assert #x900000080 + ) + +(deftype mood-clouds (structure) + ((cloud-min float :offset-assert 0) + (cloud-max float :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype mood-weather (structure) + ((data float 2 :offset-assert 0) + (cloud float :offset 0) + (fog float :offset 4) + ) + :pack-me + :allow-misaligned + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype mood-iweather (structure) + ((data int32 2 :offset-assert 0) + (cloud int32 :offset 0) + (fog int32 :offset 4) + ) + :allow-misaligned + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype mood-range (structure) + ((data float 4 :offset-assert 0) + (min-cloud float :offset 0) + (max-cloud float :offset 4) + (min-fog float :offset 8) + (max-fog float :offset 12) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype mood-filters-table (structure) + ((data vector 8 :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x80 + :flag-assert #x900000080 + ) + +(deftype mood-table (basic) + ((mood-fog-table mood-fog-table :offset-assert 4) + (mood-color-table mood-color-table :offset-assert 8) + (mood-channel-group mood-channel-group :offset-assert 12) + (mood-direction-table mood-direction-table :offset-assert 16) + (mood-sky-table mood-sky-table :offset-assert 20) + (mood-interp-table basic :offset-assert 24) + ) + :method-count-assert 9 + :size-assert #x1c + :flag-assert #x90000001c + ) + +(deftype mood-context-core (structure) + ((current-fog mood-fog :inline :offset-assert 0) + (current-sky-color vector :inline :offset-assert 48) + (current-env-color vector :inline :offset-assert 64) + (current-prt-color vector :inline :offset-assert 80) + (current-shadow-color vector :inline :offset-assert 96) + ) + :method-count-assert 9 + :size-assert #x70 + :flag-assert #x900000070 + ) + +(deftype mood-context-core2 (mood-context-core) + ((light-group light-group 8 :inline :offset-assert 112) + ) + :method-count-assert 9 + :size-assert #x670 + :flag-assert #x900000670 + ) + +(deftype mood-context-core3 (mood-context-core2) + ((times vector 8 :inline :offset-assert 1648) + ) + :method-count-assert 9 + :size-assert #x6f0 + :flag-assert #x9000006f0 + ) + +(deftype mood-context (mood-context-core3) + ((itimes vector4w 4 :inline :offset-assert 1776) + (state uint32 32 :offset-assert 1840) + ) + :method-count-assert 9 + :size-assert #x7b0 + :flag-assert #x9000007b0 + ) + +(deftype mood-control-work (structure) + ((weather mood-weather :inline :offset-assert 0) + (iweather mood-iweather :inline :offset-assert 8) + (interp mood-weather :inline :offset-assert 16) + (index int32 4 :offset-assert 24) + (color-interp float :offset-assert 40) + (color-index int32 2 :offset-assert 44) + (channel-interp float :offset-assert 52) + (channel-index int32 2 :offset-assert 56) + (cloud-interp float :offset-assert 64) + (cloud-index int32 2 :offset-assert 68) + ) + :method-count-assert 9 + :size-assert #x4c + :flag-assert #x90000004c + ) + +(deftype mood-control (mood-table) + ((mood-clouds mood-clouds :offset-assert 28) + (current-interp mood-weather :inline :offset-assert 32) + (target-interp mood-weather :inline :offset-assert 40) + (speed-interp mood-weather :inline :offset-assert 48) + (range mood-range :inline :offset-assert 64) + (time-until-random mood-weather :inline :offset-assert 80) + (time-until-random-min mood-weather :inline :offset-assert 88) + (time-until-random-max mood-weather :inline :offset-assert 96) + (display-flag basic :offset-assert 104) + (overide-weather-flag basic :offset-assert 108) + (overide mood-weather :inline :offset-assert 112) + (lightning-index int32 :offset-assert 120) + (lightning-val int32 :offset-assert 124) + (lightning-time int32 :offset-assert 128) + (lightning-time2 float :offset-assert 132) + (lightning-flash float :offset-assert 136) + (lightning-id uint32 :offset-assert 140) + (lightning-count0 uint32 :offset-assert 144) + (lightning-count1 uint32 :offset-assert 148) + (lightning-count2 uint32 :offset-assert 152) + (rain-id uint32 :offset-assert 156) + (sound-pitch float :offset-assert 160) + (fogs mood-fog 9 :offset-assert 164) + (colors mood-color 3 :offset-assert 200) + (channels mood-channel 3 :offset-assert 212) + (clouds mood-clouds 9 :offset-assert 224) + ) + :method-count-assert 19 + :size-assert #x104 + :flag-assert #x1300000104 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + ) + ) + + + diff --git a/goal_src/jak2/engine/gfx/texture/texture-anim-h.gc b/goal_src/jak2/engine/gfx/texture/texture-anim-h.gc index 94c42360c2..a0cbc03abb 100644 --- a/goal_src/jak2/engine/gfx/texture/texture-anim-h.gc +++ b/goal_src/jak2/engine/gfx/texture/texture-anim-h.gc @@ -5,3 +5,186 @@ ;; name in dgo: texture-anim-h ;; dgos: ENGINE, GAME +(deftype texture-anim-layer (structure) + ((extra vector :inline :offset 240) + (func basic :offset 256) + (func-id basic :offset 256) + (init-func basic :offset 260) + (init-func-id basic :offset 260) + (tex basic :offset 264) + (start-time float :offset 268) + (end-time float :offset 272) + (tex-name basic :offset 276) + (test uint64 :offset 280) + (alpha uint64 :offset 288) + (clamp uint64 :offset 296) + (start-color vector :inline :offset 80) + (start-scale vector2 :inline :offset 96) + (start-offset vector2 :inline :offset 104) + (start-st-scale vector2 :inline :offset 112) + (start-st-offset vector2 :inline :offset 120) + (start-qs vector :inline :offset 128) + (start-rot degrees :offset 144) + (start-st-rot degrees :offset 148) + (end-color vector :inline :offset 160) + (end-scale vector2 :inline :offset 176) + (end-offset vector2 :inline :offset 184) + (end-st-scale vector2 :inline :offset 192) + (end-st-offset vector2 :inline :offset 200) + (end-qs vector :inline :offset 208) + (end-rot degrees :offset 224) + (end-st-rot degrees :offset 228) + ) + :method-count-assert 11 + :size-assert #x130 + :flag-assert #xb00000130 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) + +(deftype texture-anim (structure) + ((num-layers uint32 :offset-assert 0) + (func basic :offset-assert 4) + (func-id basic :offset 4) + (init-func basic :offset-assert 8) + (init-func-id basic :offset 8) + (tex basic :offset-assert 12) + (tex-name basic :offset-assert 16) + (extra vector :inline :offset-assert 32) + (color uint32 :offset-assert 48) + (frame-time float :offset-assert 52) + (frame-delta float :offset-assert 56) + (frame-mod float :offset-assert 60) + (test uint64 :offset-assert 64) + (alpha uint64 :offset-assert 72) + (clamp uint64 :offset-assert 80) + (data uint8 :dynamic :offset-assert 88) + ) + :method-count-assert 11 + :size-assert #x58 + :flag-assert #xb00000058 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) + +(deftype texture-anim-array (array) + () + :method-count-assert 11 + :size-assert #x10 + :flag-assert #xb00000010 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) + +(deftype texture-anim-work (structure) + ((erase-tmpl dma-gif-packet :inline :offset-assert 0) + (draw-tmpl dma-gif-packet :inline :offset-assert 32) + (draw2-tmpl dma-gif-packet :inline :offset-assert 64) + (fill-tmpl dma-gif-packet :inline :offset-assert 96) + (adgif-tmpl dma-gif-packet :inline :offset-assert 128) + (corner0 vector :inline :offset-assert 160) + (corner1 vector :inline :offset-assert 176) + (corner2 vector :inline :offset-assert 192) + (corner3 vector :inline :offset-assert 208) + (const vector :inline :offset-assert 224) + (random vector 8 :inline :offset-assert 240) + (random-index uint8 :offset-assert 368) + ) + :method-count-assert 9 + :size-assert #x171 + :flag-assert #x900000171 + ) + +(deftype clut16x16 (structure) + ((clut rgba 256 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x400 + :flag-assert #x900000400 + ) + +(deftype noise8x8 (structure) + ((image uint8 64 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + +(deftype noise16x16 (structure) + ((image uint8 256 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x100 + :flag-assert #x900000100 + ) + +(deftype noise32x32 (structure) + ((image uint8 1024 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x400 + :flag-assert #x900000400 + ) + +(deftype noise64x64 (structure) + ((image uint8 4096 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x1000 + :flag-assert #x900001000 + ) + +(deftype noise128x128 (structure) + ((image uint8 16384 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x4000 + :flag-assert #x900004000 + ) + +(deftype fog8x256 (structure) + ((image uint8 256 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x100 + :flag-assert #x900000100 + ) + +(deftype fog-texture-work (structure) + ((corner vector 4 :inline :offset-assert 0) + (const vector :inline :offset-assert 64) + (min-corner vector :inline :offset-assert 80) + (max-corner vector :inline :offset-assert 96) + (fog-near float :offset-assert 112) + (fog-far float :offset-assert 116) + (fog-delta float :offset-assert 120) + (alpha-near float :offset-assert 124) + (alpha-far float :offset-assert 128) + (alpha-delta float :offset-assert 132) + (color uint32 :offset-assert 136) + ) + :method-count-assert 9 + :size-assert #x8c + :flag-assert #x90000008c + ) + +(define *clut-translate* + (new 'static 'array uint32 64 + #x3020100 #x7060504 #x13121110 #x17161514 #xb0a0908 #xf0e0d0c #x1b1a1918 #x1f1e1d1c + #x23222120 #x27262524 #x33323130 #x37363534 #x2b2a2928 #x2f2e2d2c #x3b3a3938 #x3f3e3d3c #x43424140 + #x47464544 #x53525150 #x57565554 #x4b4a4948 #x4f4e4d4c #x5b5a5958 #x5f5e5d5c #x63626160 #x67666564 + #x73727170 #x77767574 #x6b6a6968 #x6f6e6d6c #x7b7a7978 #x7f7e7d7c #x83828180 #x87868584 #x93929190 + #x97969594 #x8b8a8988 #x8f8e8d8c #x9b9a9998 #x9f9e9d9c #xa3a2a1a0 #xa7a6a5a4 #xb3b2b1b0 #xb7b6b5b4 + #xabaaa9a8 #xafaeadac #xbbbab9b8 #xbfbebdbc #xc3c2c1c0 #xc7c6c5c4 #xd3d2d1d0 #xd7d6d5d4 #xcbcac9c8 + #xcfcecdcc #xdbdad9d8 #xdfdedddc #xe3e2e1e0 #xe7e6e5e4 #xf3f2f1f0 #xf7f6f5f4 #xebeae9e8 #xefeeedec + #xfbfaf9f8 #xfffefdfc + ) + ) + diff --git a/goal_src/jak2/engine/gfx/texture/texture-h.gc b/goal_src/jak2/engine/gfx/texture/texture-h.gc index 59bb50568a..cf3aa87339 100644 --- a/goal_src/jak2/engine/gfx/texture/texture-h.gc +++ b/goal_src/jak2/engine/gfx/texture/texture-h.gc @@ -5,3 +5,680 @@ ;; name in dgo: texture-h ;; dgos: ENGINE, GAME +(declare-type texture-page basic) + +(defenum link-test-flags + :type uint32 + :bitfield #t + ; (needs-log-in 8) + ; (bit-9 9) + ) + +(deftype texture-id (uint32) + ((index uint16 :offset 8 :size 12) + (page uint16 :offset 20 :size 12) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype texture-pool-segment (structure) + ((dest uint32 :offset-assert 0) + (size uint32 :offset-assert 4) + ) + :pack-me + :allow-misaligned + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + + +(deftype texture-pool (basic) + ((top int32 :offset-assert 4) + (cur int32 :offset-assert 8) + (allocate-func (function texture-pool texture-page kheap int texture-page) :offset-assert 12) + (font-palette int32 :offset-assert 16) + (segment texture-pool-segment 4 :inline :offset-assert 20) + (segment-near texture-pool-segment :inline :offset 20) + (segment-common texture-pool-segment :inline :offset 28) + (common-page texture-page 32 :offset-assert 52) + (common-page-mask int32 :offset-assert 180) + (update-sprites-flag basic :offset-assert 184) + (update-flag basic :offset-assert 188) + (texture-enable-user uint64 :offset-assert 192) + (texture-enable-user-menu uint64 :offset-assert 200) + (ids uint32 128 :offset-assert 208) + ) + :method-count-assert 26 + :size-assert #x2d0 + :flag-assert #x1a000002d0 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + (dummy-24 () none 24) + (dummy-25 () none 25) + ) + ) + +(deftype texture-mask (structure) + ((mask vector4w :inline :offset-assert 0) + (dist float :offset 12) + (long uint64 2 :offset 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype texture-masks (structure) + ((data texture-mask 3 :inline :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + + +(deftype texture-masks-array (inline-array-class) + ((data texture-masks :inline :dynamic :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) +(set! (-> texture-masks-array heap-base) (the-as uint 48)) + +(define *texture-masks* (the-as texture-masks #f)) +(define *texture-masks-array* (the-as texture-masks-array #f)) + +(deftype texture (basic) + ((w int16 :offset-assert 4) + (h int16 :offset-assert 6) + (num-mips uint8 :offset-assert 8) + (tex1-control uint8 :offset-assert 9) + (psm gs-psm :offset-assert 10) + (mip-shift uint8 :offset-assert 11) + (clutpsm uint16 :offset-assert 12) + (dest uint16 7 :offset-assert 14) + (clutdest uint16 :offset-assert 28) + (width uint8 7 :offset-assert 30) + (name string :offset-assert 40) + (size uint32 :offset-assert 44) + (uv-dist float :offset-assert 48) + (pad uint32 3 :offset-assert 52) + (masks texture-masks :inline :offset-assert 64) + ) + :method-count-assert 9 + :size-assert #x70 + :flag-assert #x900000070 + ) + +(deftype texture-page-segment (structure) + ((block-data pointer :offset-assert 0) + (size uint32 :offset-assert 4) + (dest uint32 :offset-assert 8) + ) + :pack-me + :allow-misaligned + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +(defun texture-mip->segment ((arg0 int) (arg1 int)) + (if (>= 2 arg1) + (+ (- -1 arg0) arg1) + (max 0 (- 2 arg0)) + ) + ) + +(deftype texture-page (basic) + ((info file-info :offset-assert 4) + (name basic :offset-assert 8) + (id uint32 :offset-assert 12) + (length int32 :offset-assert 16) + (mip0-size uint32 :offset-assert 20) + (size uint32 :offset-assert 24) + (segment texture-page-segment 3 :inline :offset-assert 28) + (dram-size uint32 :offset-assert 64) + (pad uint32 15 :offset-assert 68) + (data texture :dynamic :offset-assert 128) + ) + :method-count-assert 14 + :size-assert #x80 + :flag-assert #xe00000080 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + ) + ) + +(deftype shader-ptr (uint32) + ((shader uint32 :offset 8 :size 24) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype texture-link (structure) + ((next shader-ptr :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype texture-page-dir-entry (structure) + ((length int16 :offset-assert 0) + (status uint16 :offset-assert 2) + (page texture-page :offset-assert 4) + (link texture-link :offset-assert 8) + ) + :pack-me + :allow-misaligned + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +(deftype texture-page-dir (basic) + ((length int32 :offset-assert 4) + (entries texture-page-dir-entry 1 :inline :offset-assert 8) + ) + :method-count-assert 10 + :size-assert #x14 + :flag-assert #xa00000014 + (:methods + (relocate (_type_ kheap (pointer uint8)) none :replace 7) + (unlink-textures-in-heap! (_type_ kheap) int 9) + ) + ) + +(deftype texture-relocate-later (basic) + ((memcpy symbol :offset-assert 4) + (dest uint32 :offset-assert 8) + (source uint32 :offset-assert 12) + (move uint32 :offset-assert 16) + (entry texture-page-dir-entry :offset-assert 20) + (page texture-page :offset-assert 24) + ) + :method-count-assert 9 + :size-assert #x1c + :flag-assert #x90000001c + ) + +(define *texture-relocate-later* (new 'global 'texture-relocate-later)) +(set! (-> *texture-relocate-later* memcpy) #f) + +(define *texture-page-dir* (the-as texture-page-dir #f)) + +(deftype adgif-shader (structure) + ((quad qword 5 :offset-assert 0) + (prims gs-reg64 10 :offset 0) + (reg-0 uint8 :offset 8) + (reg-1 uint8 :offset 24) + (reg-2 uint8 :offset 40) + (reg-3 uint8 :offset 56) + (reg-4 uint8 :offset 72) + (tex0 gs-tex0 :offset 0) + (tex1 gs-tex1 :offset 16) + (miptbp1 gs-miptbp :offset 32) + (clamp gs-clamp :offset 48) + (clamp-reg gs-reg64 :offset 56) + (alpha gs-alpha :offset 64) + (link-test link-test-flags :offset 8) + (texture-id texture-id :offset 24) + (next shader-ptr :offset 40) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) + +(deftype adgif-shader-array (inline-array-class) + ((data adgif-shader :inline :dynamic :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) +(set! (-> adgif-shader-array heap-base) (the-as uint 80)) + +(deftype texture-base (structure) + ((vram-page uint32 :offset-assert 0) + (vram-block uint32 :offset-assert 4) + (vram-word uint32 :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +(define ct32-24-block-table + (new 'static 'boxed-array :type int32 + 0 1 4 5 16 17 20 21 2 3 6 7 18 19 22 23 8 9 12 13 + 24 25 28 29 10 11 14 15 26 27 30 31 + ) + ) + +(define mz32-24-block-table + (new 'static 'boxed-array :type int32 + 16 17 20 21 0 1 4 5 18 19 22 23 2 3 6 7 24 + 25 28 29 8 9 12 13 26 27 30 31 10 11 14 15 + ) + ) + +(define ct16-block-table + (new 'static 'boxed-array :type int32 + 0 2 8 10 1 3 9 11 4 6 12 14 5 7 13 15 16 + 18 24 26 17 19 25 27 20 22 28 30 21 23 29 31 + ) + ) + +(define ct16s-block-table + (new 'static 'boxed-array :type int32 + 0 2 16 18 1 3 17 19 8 10 24 26 9 11 25 27 4 + 6 20 22 5 7 21 23 12 14 28 30 13 15 29 31 + ) + ) + +(define mz16-block-table + (new 'static 'boxed-array :type int32 + 16 18 24 26 17 19 25 27 20 22 28 30 21 23 + 29 31 0 2 8 10 1 3 9 11 4 6 12 14 5 7 13 15 + ) + ) + +(define mz16s-block-table + (new 'static 'boxed-array :type int32 + 16 18 0 2 17 19 1 3 24 26 8 10 25 27 9 + 11 20 22 4 6 21 23 5 7 28 30 12 14 29 31 13 15 + ) + ) + +(define mt8-block-table + (new 'static 'boxed-array :type int32 + 0 1 4 5 16 17 20 21 2 3 6 7 18 19 22 23 8 9 12 13 + 24 25 28 29 10 11 14 15 26 27 30 31 + ) + ) + +(define mt4-block-table + (new 'static 'boxed-array :type int32 + 0 2 8 10 1 3 9 11 4 6 12 14 5 7 13 15 + 16 18 24 26 17 19 25 27 20 22 28 30 21 23 29 31 + ) + ) + + +(deftype texture-page-translate-item (structure) + ((bucket bucket-id :offset-assert 0) + (level-index uint32 :offset-assert 4) + (level-texture-page uint32 :offset-assert 8) + (texture-user uint32 :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(define *texture-page-translate* + (new 'static 'boxed-array :type texture-page-translate-item + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-4) + :level-index #x6 + :level-texture-page #x9 + :texture-user #x100 + ) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-7) :texture-user #x1) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-18) :level-index #x1 :texture-user #x1) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-29) :level-index #x2 :texture-user #x1) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-40) :level-index #x3 :texture-user #x1) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-51) :level-index #x4 :texture-user #x1) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-62) :level-index #x5 :texture-user #x1) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-73) :level-texture-page #x2 :texture-user #x4) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-82) :level-index #x1 :level-texture-page #x2 :texture-user #x4) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-91) :level-index #x2 :level-texture-page #x2 :texture-user #x4) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-100) :level-index #x3 :level-texture-page #x2 :texture-user #x4) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-109) + :level-index #x4 + :level-texture-page #x2 + :texture-user #x4 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-118) + :level-index #x5 + :level-texture-page #x2 + :texture-user #x4 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-127) + :level-texture-page #x3 + :texture-user #x8 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-137) + :level-index #x1 + :level-texture-page #x3 + :texture-user #x8 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-147) + :level-index #x2 + :level-texture-page #x3 + :texture-user #x8 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-157) + :level-index #x3 + :level-texture-page #x3 + :texture-user #x8 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-167) + :level-index #x4 + :level-texture-page #x3 + :texture-user #x8 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-177) + :level-index #x5 + :level-texture-page #x3 + :texture-user #x8 + ) + (new 'static 'texture-page-translate-item :bucket (bucket-id bucket-187) :level-index #x6 :texture-user #x1) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-191) + :level-index #x6 + :level-texture-page #x2 + :texture-user #x4 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-196) + :level-texture-page #x1 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-200) + :level-index #x1 + :level-texture-page #x1 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-204) + :level-index #x2 + :level-texture-page #x1 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-208) + :level-index #x3 + :level-texture-page #x1 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-212) + :level-index #x4 + :level-texture-page #x1 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-216) + :level-index #x5 + :level-texture-page #x1 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-220) + :level-index #x6 + :level-texture-page #x1 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-224) + :level-texture-page #x6 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-228) + :level-index #x1 + :level-texture-page #x6 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-232) + :level-index #x2 + :level-texture-page #x6 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-236) + :level-index #x3 + :level-texture-page #x6 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-240) + :level-index #x4 + :level-texture-page #x6 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-244) + :level-index #x5 + :level-texture-page #x6 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-248) + :level-index #x6 + :level-texture-page #x6 + :texture-user #x2 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-252) + :level-texture-page #x4 + :texture-user #x10 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-261) + :level-index #x1 + :level-texture-page #x4 + :texture-user #x10 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-270) + :level-index #x2 + :level-texture-page #x4 + :texture-user #x10 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-279) + :level-index #x3 + :level-texture-page #x4 + :texture-user #x10 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-288) + :level-index #x4 + :level-texture-page #x4 + :texture-user #x10 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-297) + :level-index #x5 + :level-texture-page #x4 + :texture-user #x10 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-306) + :level-index #x6 + :level-texture-page #x4 + :texture-user #x10 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-309) + :level-index #x6 + :level-texture-page #x9 + :texture-user #x100 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-312) + :level-texture-page #x7 + :texture-user #x40 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-312) + :level-index #x1 + :level-texture-page #x7 + :texture-user #x40 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-312) + :level-index #x2 + :level-texture-page #x7 + :texture-user #x40 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-312) + :level-index #x3 + :level-texture-page #x7 + :texture-user #x40 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-312) + :level-index #x4 + :level-texture-page #x7 + :texture-user #x40 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-312) + :level-index #x5 + :level-texture-page #x7 + :texture-user #x40 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-312) + :level-index #x6 + :level-texture-page #x7 + :texture-user #x40 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-316) + :level-texture-page #x5 + :texture-user #x20 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-316) + :level-index #x1 + :level-texture-page #x5 + :texture-user #x20 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-316) + :level-index #x2 + :level-texture-page #x5 + :texture-user #x20 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-316) + :level-index #x3 + :level-texture-page #x5 + :texture-user #x20 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-316) + :level-index #x4 + :level-texture-page #x5 + :texture-user #x20 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-316) + :level-index #x5 + :level-texture-page #x5 + :texture-user #x20 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-316) + :level-index #x6 + :level-texture-page #x5 + :texture-user #x20 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-319) + :level-texture-page #x8 + :texture-user #x80 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-319) + :level-index #x1 + :level-texture-page #x8 + :texture-user #x80 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-319) + :level-index #x2 + :level-texture-page #x8 + :texture-user #x80 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-319) + :level-index #x3 + :level-texture-page #x8 + :texture-user #x80 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-319) + :level-index #x4 + :level-texture-page #x8 + :texture-user #x80 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-319) + :level-index #x5 + :level-texture-page #x8 + :texture-user #x80 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-319) + :level-index #x6 + :level-texture-page #x8 + :texture-user #x80 + ) + (new 'static 'texture-page-translate-item + :bucket (bucket-id bucket-319) + :level-index #x6 + :level-texture-page #x3 + :texture-user #x80 + ) + ) + ) + +(define *eyes-texture-base* (new 'static 'texture-base)) +(define *skull-gem-texture-base* (new 'static 'texture-base)) +(define *ocean-texture-base* (new 'static 'texture-base)) +(define *ocean-envmap-texture-base* (new 'static 'texture-base)) +(define *grey-scale-base* (new 'static 'texture-base)) +(define *map-texture-base* (new 'static 'texture-base)) + diff --git a/goal_src/jak2/engine/gfx/vu1-user-h.gc b/goal_src/jak2/engine/gfx/vu1-user-h.gc index 7309efb872..a85caf875c 100644 --- a/goal_src/jak2/engine/gfx/vu1-user-h.gc +++ b/goal_src/jak2/engine/gfx/vu1-user-h.gc @@ -5,3 +5,403 @@ ;; name in dgo: vu1-user-h ;; dgos: ENGINE, GAME +(defenum bucket-id + :type int32 + :bitfield #f + (bucket-0 0) + (bucket-1 1) + (bucket-2 2) + (bucket-3 3) + (bucket-4 4) + (bucket-5 5) + (bucket-6 6) + (bucket-7 7) ;; level 0 tex + (bucket-8 8) + (bucket-9 9) + (bucket-10 10) + (bucket-11 11) + (bucket-12 12) + (bucket-13 13) + (bucket-14 14) + (bucket-15 15) + (bucket-16 16) + (bucket-17 17) + (bucket-18 18) + (bucket-19 19) + (bucket-20 20) + (bucket-21 21) + (bucket-22 22) + (bucket-23 23) + (bucket-24 24) + (bucket-25 25) + (bucket-26 26) + (bucket-27 27) + (bucket-28 28) + (bucket-29 29) + (bucket-30 30) + (bucket-31 31) + (bucket-32 32) + (bucket-33 33) + (bucket-34 34) + (bucket-35 35) + (bucket-36 36) + (bucket-37 37) + (bucket-38 38) + (bucket-39 39) + (bucket-40 40) + (bucket-41 41) + (bucket-42 42) + (bucket-43 43) + (bucket-44 44) + (bucket-45 45) + (bucket-46 46) + (bucket-47 47) + (bucket-48 48) + (bucket-49 49) + (bucket-50 50) + (bucket-51 51) + (bucket-52 52) + (bucket-53 53) + (bucket-54 54) + (bucket-55 55) + (bucket-56 56) + (bucket-57 57) + (bucket-58 58) + (bucket-59 59) + (bucket-60 60) + (bucket-61 61) + (bucket-62 62) + (bucket-63 63) + (bucket-64 64) + (bucket-65 65) + (bucket-66 66) + (bucket-67 67) + (bucket-68 68) + (bucket-69 69) + (bucket-70 70) + (bucket-71 71) + (bucket-72 72) + (bucket-73 73) + (bucket-74 74) + (bucket-75 75) + (bucket-76 76) + (bucket-77 77) + (bucket-78 78) + (bucket-79 79) + (bucket-80 80) + (bucket-81 81) + (bucket-82 82) + (bucket-83 83) + (bucket-84 84) + (bucket-85 85) + (bucket-86 86) + (bucket-87 87) + (bucket-88 88) + (bucket-89 89) + (bucket-90 90) + (bucket-91 91) + (bucket-92 92) + (bucket-93 93) + (bucket-94 94) + (bucket-95 95) + (bucket-96 96) + (bucket-97 97) + (bucket-98 98) + (bucket-99 99) + (bucket-100 100) + (bucket-101 101) + (bucket-102 102) + (bucket-103 103) + (bucket-104 104) + (bucket-105 105) + (bucket-106 106) + (bucket-107 107) + (bucket-108 108) + (bucket-109 109) + (bucket-110 110) + (bucket-111 111) + (bucket-112 112) + (bucket-113 113) + (bucket-114 114) + (bucket-115 115) + (bucket-116 116) + (bucket-117 117) + (bucket-118 118) + (bucket-119 119) + (bucket-120 120) + (bucket-121 121) + (bucket-122 122) + (bucket-123 123) + (bucket-124 124) + (bucket-125 125) + (bucket-126 126) + (bucket-127 127) + (bucket-128 128) + (bucket-129 129) + (bucket-130 130) + (bucket-131 131) + (bucket-132 132) + (bucket-133 133) + (bucket-134 134) + (bucket-135 135) + (bucket-136 136) + (bucket-137 137) + (bucket-138 138) + (bucket-139 139) + (bucket-140 140) + (bucket-141 141) + (bucket-142 142) + (bucket-143 143) + (bucket-144 144) + (bucket-145 145) + (bucket-146 146) + (bucket-147 147) + (bucket-148 148) + (bucket-149 149) + (bucket-150 150) + (bucket-151 151) + (bucket-152 152) + (bucket-153 153) + (bucket-154 154) + (bucket-155 155) + (bucket-156 156) + (bucket-157 157) + (bucket-158 158) + (bucket-159 159) + (bucket-160 160) + (bucket-161 161) + (bucket-162 162) + (bucket-163 163) + (bucket-164 164) + (bucket-165 165) + (bucket-166 166) + (bucket-167 167) + (bucket-168 168) + (bucket-169 169) + (bucket-170 170) + (bucket-171 171) + (bucket-172 172) + (bucket-173 173) + (bucket-174 174) + (bucket-175 175) + (bucket-176 176) + (bucket-177 177) + (bucket-178 178) + (bucket-179 179) + (bucket-180 180) + (bucket-181 181) + (bucket-182 182) + (bucket-183 183) + (bucket-184 184) + (bucket-185 185) + (bucket-186 186) + (bucket-187 187) + (bucket-188 188) + (bucket-189 189) + (bucket-190 190) + (bucket-191 191) + (bucket-192 192) + (bucket-193 193) + (bucket-194 194) + (bucket-195 195) + (bucket-196 196) + (bucket-197 197) + (bucket-198 198) + (bucket-199 199) + (bucket-200 200) + (bucket-201 201) + (bucket-202 202) + (bucket-203 203) + (bucket-204 204) + (bucket-205 205) + (bucket-206 206) + (bucket-207 207) + (bucket-208 208) + (bucket-209 209) + (bucket-210 210) + (bucket-211 211) + (bucket-212 212) + (bucket-213 213) + (bucket-214 214) + (bucket-215 215) + (bucket-216 216) + (bucket-217 217) + (bucket-218 218) + (bucket-219 219) + (bucket-220 220) + (bucket-221 221) + (bucket-222 222) + (bucket-223 223) + (bucket-224 224) + (bucket-225 225) + (bucket-226 226) + (bucket-227 227) + (bucket-228 228) + (bucket-229 229) + (bucket-230 230) + (bucket-231 231) + (bucket-232 232) + (bucket-233 233) + (bucket-234 234) + (bucket-235 235) + (bucket-236 236) + (bucket-237 237) + (bucket-238 238) + (bucket-239 239) + (bucket-240 240) + (bucket-241 241) + (bucket-242 242) + (bucket-243 243) + (bucket-244 244) + (bucket-245 245) + (bucket-246 246) + (bucket-247 247) + (bucket-248 248) + (bucket-249 249) + (bucket-250 250) + (bucket-251 251) + (bucket-252 252) + (bucket-253 253) + (bucket-254 254) + (bucket-255 255) + (bucket-256 256) + (bucket-257 257) + (bucket-258 258) + (bucket-259 259) + (bucket-260 260) + (bucket-261 261) + (bucket-262 262) + (bucket-263 263) + (bucket-264 264) + (bucket-265 265) + (bucket-266 266) + (bucket-267 267) + (bucket-268 268) + (bucket-269 269) + (bucket-270 270) + (bucket-271 271) + (bucket-272 272) + (bucket-273 273) + (bucket-274 274) + (bucket-275 275) + (bucket-276 276) + (bucket-277 277) + (bucket-278 278) + (bucket-279 279) + (bucket-280 280) + (bucket-281 281) + (bucket-282 282) + (bucket-283 283) + (bucket-284 284) + (bucket-285 285) + (bucket-286 286) + (bucket-287 287) + (bucket-288 288) + (bucket-289 289) + (bucket-290 290) + (bucket-291 291) + (bucket-292 292) + (bucket-293 293) + (bucket-294 294) + (bucket-295 295) + (bucket-296 296) + (bucket-297 297) + (bucket-298 298) + (bucket-299 299) + (bucket-300 300) + (bucket-301 301) + (bucket-302 302) + (bucket-303 303) + (bucket-304 304) + (bucket-305 305) + (bucket-306 306) + (bucket-307 307) + (bucket-308 308) + (bucket-309 309) + (bucket-310 310) + (bucket-311 311) + (bucket-312 312) + (bucket-313 313) + (bucket-314 314) + (bucket-315 315) + (bucket-316 316) + (bucket-317 317) + (bucket-318 318) + (bucket-319 319) + (bucket-320 320) + (bucket-321 321) + (bucket-322 322) + (bucket-323 323) + (bucket-324 324) + (debug 325) + ) + + +(defenum vu1-renderer-mask + :type uint64 + :bitfield #t + (rn0) + (rn1) + (rn2) + (rn3) + (rn4) + (rn5) + (rn6) + (rn7) + (rn8) + (rn9) + (rn10) + (rn11) + (rn12) + (rn13) + (rn14) + (rn15) + (rn16) + (rn17) + (rn18) + (rn19) + (rn20) + (rn21) + (rn22) + (rn23) + (rn24) + (rn25) + (rn26) + (rn27) + (rn28) + (rn29) + (rn30) + (rn31) + (rn32) + (rn33) + (rn34) + ) + +(deftype dma-foreground-sink (basic) + ((bucket bucket-id :offset-assert 4) + (foreground-texture-page int8 :offset-assert 8) + (foreground-texture-level int8 :offset-assert 9) + (foreground-output-bucket int8 :offset-assert 10) + ) + :method-count-assert 9 + :size-assert #xb + :flag-assert #x90000000b + ) + +(deftype generic-bucket-state (structure) + ((gifbuf-adr uint32 :offset-assert 0) + (inbuf-adr uint32 :offset-assert 4) + ) + :allow-misaligned + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype generic-dma-foreground-sink (dma-foreground-sink) + ((state generic-bucket-state :inline :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + ) diff --git a/goal_src/jak2/engine/level/level-h.gc b/goal_src/jak2/engine/level/level-h.gc index be37089a27..28ffe27dd3 100644 --- a/goal_src/jak2/engine/level/level-h.gc +++ b/goal_src/jak2/engine/level/level-h.gc @@ -5,3 +5,490 @@ ;; name in dgo: level-h ;; dgos: ENGINE, GAME +(declare-type bsp-header basic) +(declare-type drawable basic) +(declare-type entity-links structure) + +(defenum vis-info-flag + :type uint32 + :bitfield #t + (dummy0 0) + (dummy1 1) + (dummy2 2) + (dummy3 3) + (dummy4 4) + (dummy5 5) + (dummy6 6) + (dummy7 7) + (dummy8 8) + (dummy9 9) + (dummy10 10) + (dummy11 11) + (dummy12 12) + (dummy13 13) + (dummy14 14) + (dummy15 15) + (dummy16 16) + (dummy17 17) + (dummy18 18) + (dummy19 19) + (dummy20 20) + (dummy21 21) + (dummy22 22) + (dummy23 23) + (dummy24 24) + (dummy25 25) + (dummy26 26) + (dummy27 27) + (dummy28 28) + (in-iop 29) + (loading 30) + (vis-valid 31) + ) + +(defenum task-mask + :type uint32 + :bitfield #t + (task0 0) ;; 0x1 + (task1 1) ;; 0x2 + (task2 2) ;; 0x4 + (task3 3) ;; 0x8 + (task4 4) ;; 0x10 + (task5 5) ;; 0x20 + (task6 6) ;; 0x40 + (task7 7) ;; 0x80 + (done 8) ;; 0x100 + (dummy0 9) ;; 0x200 + (dummy1 10) ;; 0x400 + (dummy2 11) ;; 0x800 + (special 12) ;; 0x1000 + (primary0 13) ;; 0x2000 + (ctywide 14) ;; 0x4000 + (never 15) ;; 0x8000 + (movie0 16) ;; 0x10000 + (movie1 17) ;; 0x20000 + (movie2 18) ;; 0x40000 + ) + +(deftype level-vis-info (basic) + ((level level :offset-assert 4) + (from-level level :offset-assert 8) + (from-bsp bsp-header :offset-assert 12) + (flags vis-info-flag :offset-assert 16) + (length uint32 :offset-assert 20) + (allocated-length uint32 :offset-assert 24) + (dictionary-length uint32 :offset-assert 28) + (dictionary uint32 :offset-assert 32) + (string-block uint32 :offset-assert 36) + (ramdisk uint32 :offset-assert 40) + (vis-bits uint32 :offset-assert 44) + (current-vis-string uint32 :offset-assert 48) + (vis-string uint32 :dynamic :offset-assert 52) + ) + :method-count-assert 9 + :size-assert #x34 + :flag-assert #x900000034 + ) + +(defmethod asize-of level-vis-info ((obj level-vis-info)) + (the-as int (+ (-> level-vis-info size) (-> obj dictionary-length))) + ) + +(deftype level-load-info (basic) + ((name-list string 6 :offset-assert 4) + (index int16 :offset-assert 28) + (task-level uint8 :offset-assert 30) + (name string :offset 4) + (visname string :offset 8) + (nickname string :offset 12) + (dbname string :offset 16) + (taskname string :offset 20) + (packages pair :offset-assert 32) + (memory-mode uint32 :offset-assert 36) + (music-bank basic :offset-assert 40) + (ambient-sounds basic :offset-assert 44) + (sound-reverb float :offset-assert 48) + (mood-func basic :offset-assert 52) + (mood-init basic :offset-assert 56) + (ocean basic :offset-assert 60) + (sky basic :offset-assert 64) + (use-camera-other basic :offset-assert 68) + (part-engine-max int32 :offset-assert 72) + (city-map-bits uint64 :offset-assert 80) + (continues basic :offset-assert 88) + (tasks basic :offset-assert 92) + (priority int32 :offset-assert 96) + (load-commands basic :offset-assert 100) + (alt-load-commands basic :offset-assert 104) + (bsp-mask uint64 :offset-assert 112) + (buzzer int32 :offset-assert 120) + (buttom-height meters :offset-assert 124) + (run-packages basic :offset-assert 128) + (prev-level basic :offset-assert 132) + (next-level basic :offset-assert 136) + (wait-for-load symbol :offset-assert 140) + (login-func basic :offset-assert 144) + (activate-func basic :offset-assert 148) + (deactivate-func basic :offset-assert 152) + (kill-func basic :offset-assert 156) + (borrow-size uint16 2 :offset-assert 160) + (borrow-level symbol 2 :offset-assert 164) + (borrow-display? basic 2 :offset-assert 172) + (base-task-mask task-mask :offset-assert 180) + (texture-anim basic 10 :offset-assert 184) + (texture-anim-tfrag basic :offset 184) + (texture-anim-pris basic :offset 188) + (texture-anim-shrub basic :offset 192) + (texture-anim-alpha basic :offset 196) + (texture-anim-water basic :offset 200) + (texture-anim-twarp basic :offset 204) + (texture-anim-pris2 basic :offset 208) + (texture-anim-sprite basic :offset 212) + (texture-anim-map basic :offset 216) + (texture-anim-sky basic :offset 220) + (draw-priority float :offset-assert 224) + (level-flags uint32 :offset-assert 228) + (fog-height float :offset-assert 232) + (bigmap-id uint32 :offset-assert 236) + (ocean-near-translucent? symbol :offset-assert 240) + (ocean-far? symbol :offset-assert 244) + (mood-range mood-range :inline :offset-assert 256) + (max-rain float :offset-assert 272) + (fog-mult float :offset-assert 276) + (ocean-alpha float :offset-assert 280) + (extra-sound-bank basic :offset-assert 284) + ) + :method-count-assert 9 + :size-assert #x120 + :flag-assert #x900000120 + ) + +(deftype login-state (basic) + ((state int32 :offset-assert 4) + (pos uint32 :offset-assert 8) + (elts uint32 :offset-assert 12) + (elt drawable 16 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) + +(deftype level (basic) + ((name symbol :offset-assert 4) + (load-name basic :offset-assert 8) + (nickname basic :offset-assert 12) + (index int32 :offset-assert 16) + (status symbol :offset-assert 20) + (borrow-level basic 2 :offset-assert 24) + (borrow-from-level basic :offset-assert 32) + (heap kheap :inline :offset-assert 48) + (borrow-heap kheap 2 :inline :offset-assert 64) + (bsp bsp-header :offset-assert 96) + (art-group basic :offset-assert 100) + (info basic :offset-assert 104) + (texture-page texture-page 18 :offset-assert 108) + (loaded-texture-page texture-page 16 :offset-assert 180) + (loaded-texture-page-count int32 :offset-assert 244) + (entity basic :offset-assert 248) + (closest-object float :offset-assert 252) + (upload-size int32 18 :offset 324) + (inside-boxes symbol :offset-assert 396) + (display? symbol :offset-assert 400) + (render? symbol :offset-assert 404) + (meta-inside? symbol :offset-assert 408) + (force-inside? symbol :offset-assert 412) + (mood-context mood-context :inline :offset-assert 416) + (mood-func basic :offset-assert 2384) + (mood-init basic :offset-assert 2388) + (vis-bits pointer :offset-assert 2392) + (all-visible? symbol :offset-assert 2396) + (force-all-visible? symbol :offset-assert 2400) + (linking basic :offset-assert 2404) + (vis-info level-vis-info 8 :offset-assert 2408) + (vis-self-index int32 :offset-assert 2440) + (vis-adj-index int32 :offset-assert 2444) + (vis-buffer uint8 2048 :offset-assert 2448) + (mem-usage-block basic :offset-assert 4496) + (mem-usage int32 :offset-assert 4500) + (code-memory-start pointer :offset-assert 4504) + (code-memory-end pointer :offset-assert 4508) + (load-start-time time-frame :offset-assert 4512) + (load-stop-time time-frame :offset-assert 4520) + (load-buffer basic 2 :offset-assert 4528) + (load-buffer-size uint32 :offset-assert 4536) + (load-buffer-last uint32 :offset-assert 4540) + (load-buffer-mode uint32 :offset-assert 4544) + (display-start-time time-frame :offset-assert 4552) + (memory-mask uint32 :offset-assert 4560) + (task-mask task-mask :offset-assert 4564) + (tfrag-gs-test uint64 :offset-assert 4568) + (texture-dirty-masks texture-mask 10 :inline :offset-assert 4576) + (texture-mask texture-mask 18 :inline :offset-assert 4736) + (sky-mask texture-mask :inline :offset-assert 5024) + (tfrag-masks basic :offset-assert 5040) + (tfrag-dists pointer :offset-assert 5044) + (shrub-masks basic :offset-assert 5048) + (shrub-dists pointer :offset-assert 5052) + (alpha-masks basic :offset-assert 5056) + (alpha-dists pointer :offset-assert 5060) + (water-masks basic :offset-assert 5064) + (water-dists pointer :offset-assert 5068) + (tfrag-last-calls int32 6 :offset-assert 5072) + (texture-anim-array texture-anim-array 10 :offset-assert 5096) + (light-hash basic :offset-assert 5136) + (draw-priority float :offset-assert 5140) + (draw-index int32 :offset-assert 5144) + (part-engine basic :offset-assert 5148) + (user-object basic 4 :offset-assert 5152) + (loaded-text-info-count int32 :offset-assert 5168) + (loaded-text-info object 8 :offset-assert 5172) + (level-type basic :offset-assert 5204) + (load-order int64 :offset-assert 5208) + (pad int8 12 :offset-assert 5216) + ) + :method-count-assert 30 + :size-assert #x146c + :flag-assert #x1e0000146c + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + (dummy-24 () none 24) + (dummy-25 () none 25) + (dummy-26 () none 26) + (dummy-27 () none 27) + (dummy-28 () none 28) + (dummy-29 () none 29) + ) + ) + +(deftype level-group (basic) + ((length int32 :offset-assert 4) + (log-in-level-bsp bsp-header :offset-assert 8) + (loading-level level :offset-assert 12) + (entity-link entity-links :offset 16) + (border? symbol :offset-assert 20) + (vis? symbol :offset-assert 24) + (want-level basic :offset-assert 28) + (receiving-level basic :offset-assert 32) + (load-commands basic :offset-assert 36) + (play? symbol :offset-assert 40) + (target-pos vector 2 :inline :offset-assert 48) + (camera-pos vector 2 :inline :offset-assert 80) + (heap kheap :inline :offset-assert 112) + (sound-bank basic 4 :offset-assert 128) + (disk-load-timing? symbol :offset-assert 144) + (load-level basic :offset-assert 148) + (load-size uint32 :offset-assert 152) + (load-time float :offset-assert 156) + (load-login-time float :offset-assert 160) + (draw-level-count int32 :offset-assert 164) + (draw-level basic 7 :offset-assert 168) + (draw-index-map uint8 7 :offset-assert 196) + (load-order uint64 :offset-assert 208) + (pad uint8 30 :offset-assert 216) + (level level 7 :inline :offset-assert 256) + (level0 level :inline :offset 256) + (level1 level :inline :offset 5488) + (level2 level :inline :offset 10720) + (level3 level :inline :offset 15952) + (level4 level :inline :offset 21184) + (level5 level :inline :offset 26416) + (default-level level :inline :offset 31648) + (pad2 uint8 4 :offset-assert 36880) + ) + :method-count-assert 31 + :size-assert #x9014 + :flag-assert #x1f00009014 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + (dummy-16 () none 16) + (dummy-17 () none 17) + (dummy-18 () none 18) + (dummy-19 () none 19) + (dummy-20 () none 20) + (dummy-21 () none 21) + (dummy-22 () none 22) + (dummy-23 () none 23) + (dummy-24 () none 24) + (dummy-25 () none 25) + (dummy-26 () none 26) + (dummy-27 () none 27) + (dummy-28 () none 28) + (dummy-29 () none 29) + (dummy-30 () none 30) + ) + ) + +(defmethod inspect level-group ((obj level-group)) + (when (not obj) + (set! obj obj) + (goto cfg-13) + ) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~1Tlength: ~D~%" (-> obj length)) + (format #t "~1Tentity-link: ~`entity-links`P~%" (-> obj entity-link)) + (format #t "~1Tborder?: ~A~%" (-> obj border?)) + (format #t "~1Tvis?: ~A~%" (-> obj vis?)) + (format #t "~1Twant-level: ~A~%" (-> obj want-level)) + (format #t "~1Treceiving-level: ~A~%" (-> obj receiving-level)) + (format #t "~1Tload-commands: ~A~%" (-> obj load-commands)) + (format #t "~1Tplay?: ~A~%" (-> obj play?)) + (format #t "~1Ttarget-pos[2] @ #x~X~%" (-> obj target-pos)) + (dotimes (s5-0 2) + (format #t "~T [~D]~1Ttarget-pos: ~`vector`P~%" s5-0 (-> obj target-pos s5-0)) + ) + (format #t "~1Tcamera-pos[2] @ #x~X~%" (-> obj camera-pos)) + (dotimes (s5-1 2) + (format #t "~T [~D]~1Tcamera-pos: ~`vector`P~%" s5-1 (-> obj camera-pos s5-1)) + ) + (format #t "~1Theap: #~%" (-> obj heap)) + (format #t "~1Tsound-bank[4] @ #x~X~%" (-> obj sound-bank)) + (format #t "~1Tdisk-load-timing?: ~A~%" (-> obj disk-load-timing?)) + (format #t "~1Tload-level: ~A~%" (-> obj load-level)) + (format #t "~1Tload-size: ~D~%" (-> obj load-size)) + (format #t "~1Tload-time: ~f~%" (-> obj load-time)) + (format #t "~1Tload-login-time: ~f~%" (-> obj load-login-time)) + (format #t "~1Tdraw-level-count: ~D~%" (-> obj draw-level-count)) + (format #t "~1Tdraw-level[7] @ #x~X~%" (-> obj draw-level)) + (dotimes (s5-2 (-> obj draw-level-count)) + (format #t "~T [~D]~1Tdraw-level: ~`object`P~%" s5-2 (-> obj draw-level s5-2)) + ) + (format #t "~1Tdraw-index-map[7] @ #x~X~%" (-> obj draw-index-map)) + (format #t "~1Tload-order: ~D~%" (-> obj load-order)) + (format #t "~1Tlevel[7] @ #x~X~%" (-> obj level)) + (format #t "~1Tdata[7] @ #x~X~%" (-> obj level)) + (format #t "~1Tlevel0: ~`level`P~%" (-> obj level)) + (format #t "~1Tlevel1: ~`level`P~%" (-> obj level1)) + (format #t "~1Tlevel2: ~`level`P~%" (-> obj level2)) + (format #t "~1Tlevel3: ~`level`P~%" (-> obj level3)) + (format #t "~1Tlevel4: ~`level`P~%" (-> obj level4)) + (format #t "~1Tlevel5: ~`level`P~%" (-> obj level5)) + (format #t "~1Tlevel-default: ~`level`P~%" (-> obj default-level)) + (label cfg-13) + obj + ) + +(define-extern *level* level-group) +(when (zero? *level*) + (define *level* (new 'static 'level-group + :length 6 + :log-in-level-bsp #f + :loading-level #f + :entity-link #f + :border? #f + :vis? #f + :want-level #f + :load-commands '() + :play? #f + :sound-bank (new 'static 'array basic 4 #f #f #f #f) + :disk-load-timing? #f + :level (new 'static 'inline-array level 7 + (new 'static 'level + :name #f + :status 'inactive + :borrow-level (new 'static 'array basic 2 #f #f) + :borrow-from-level #f + :inside-boxes #f + :force-inside? #f + :linking #f + :level-type #f + ) + (new 'static 'level + :name #f + :index 1 + :status 'inactive + :borrow-level (new 'static 'array basic 2 #f #f) + :borrow-from-level #f + :inside-boxes #f + :force-inside? #f + :linking #f + :level-type #f + ) + (new 'static 'level + :name #f + :index 2 + :status 'inactive + :borrow-level (new 'static 'array basic 2 #f #f) + :borrow-from-level #f + :inside-boxes #f + :force-inside? #f + :linking #f + :level-type #f + ) + (new 'static 'level + :name #f + :index 3 + :status 'inactive + :borrow-level (new 'static 'array basic 2 #f #f) + :borrow-from-level #f + :inside-boxes #f + :force-inside? #f + :linking #f + :level-type #f + ) + (new 'static 'level + :name #f + :index 4 + :status 'inactive + :borrow-level (new 'static 'array basic 2 #f #f) + :borrow-from-level #f + :inside-boxes #f + :force-inside? #f + :linking #f + :level-type #f + ) + (new 'static 'level + :name #f + :index 5 + :status 'inactive + :borrow-level (new 'static 'array basic 2 #f #f) + :borrow-from-level #f + :inside-boxes #f + :force-inside? #f + :linking #f + :level-type #f + ) + (new 'static 'level + :name 'default + :index 6 + :status 'reserved + :borrow-level (new 'static 'array basic 2 #f #f) + :borrow-from-level #f + :bsp #f + :inside-boxes #f + :display? #f + :force-inside? #f + :linking #f + :level-type #f + ) + ) + ) + ) + + 0 + ) +(define *draw-index* 0) +(define *level-index* 0) + + + diff --git a/goal_src/jak2/engine/load/file-io.gc b/goal_src/jak2/engine/load/file-io.gc index 388aa3fec3..38a0dcb22f 100644 --- a/goal_src/jak2/engine/load/file-io.gc +++ b/goal_src/jak2/engine/load/file-io.gc @@ -5,3 +5,187 @@ ;; name in dgo: file-io ;; dgos: ENGINE, GAME +(defenum file-kind + :bitfield #f + (level-bt 0) ;; aka bsp-header. + (art-group 1) + (tpage 2) + (dir-tpage 3) + (level-vs 4) + (tx 5) + (vis 6) + (map 7) + ) + +(deftype file-stream (basic) + ((flags uint32 :offset-assert 4) + (mode symbol :offset-assert 8) + (name string :offset-assert 12) + (file uint32 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + (:methods + (new (symbol type string symbol) _type_ 0) + ) + ) + +(defmethod new file-stream ((allocation symbol) (type-to-make type) (arg0 string) (arg1 symbol)) + (let ((a0-1 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (file-stream-open a0-1 arg0 arg1) + ) + ) +(set! (-> file-stream method-table 4) file-stream-length) + +(defun file-stream-read-string ((arg0 file-stream) (arg1 string)) + (clear arg1) + (file-stream-read arg0 (-> arg1 data) (length arg0)) + arg1 + ) + +(deftype file-info (basic) + ((file-type (pointer string) :offset-assert 4) ;; something funny here... + (file-name basic :offset-assert 8) + (major-version uint32 :offset-assert 12) + (minor-version uint32 :offset-assert 16) + (maya-file-name basic :offset-assert 20) + (tool-debug basic :offset-assert 24) + (mdb-file-name basic :offset-assert 28) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(defmethod print file-info ((obj file-info)) + (format + #t + "#<~A ~A :version ~D.~D @ #x~X>" + (-> obj type) + (-> obj file-name) + (-> obj major-version) + (-> obj minor-version) + obj + ) + obj + ) + +(define *file-temp-string* (new 'global 'string 128 (the-as string #f))) + +(defun make-file-name ((arg0 file-kind) (arg1 string) (arg2 int) (arg3 symbol)) + (clear *file-temp-string*) + (cond + ((= arg0 (file-kind dir-tpage)) + (format *file-temp-string* "texture-page~D/dir-tpages" 8) + ) + ((= arg0 (file-kind tpage)) + (format *file-temp-string* "texture-page~D/tpage-~S" 8 arg1) + ) + ((= arg0 (file-kind level-bt)) + (format *file-temp-string* "level~D/~S-bt" 36 arg1) + ) + ((= arg0 (file-kind tx)) + (format *file-temp-string* "res~D/~S-tx" 1 arg1) + ) + ((= arg0 (file-kind level-vs)) + (format *file-temp-string* "level~D/~S-vs" 36 arg1) + ) + ((= arg0 (file-kind vis)) + (format *file-temp-string* "~S.VIS" arg1) + ) + ((= arg0 (file-kind map)) + (format *file-temp-string* "map~D/~S-mp" 1 arg1) + ) + ((= arg0 (file-kind art-group)) + (format + *file-temp-string* + "art-group~D/~S-ag" + (cond + ((> arg2 0) + arg2 + ) + (else + 7 + ) + ) + arg1 + ) + ) + ) + *file-temp-string* + ) + +(defun make-vfile-name ((arg0 file-kind) (arg1 string)) + (clear *file-temp-string*) + (cond + ((= arg0 (file-kind level-bt)) + (format *file-temp-string* "$LEVEL/~S" arg1) + ) + ((= arg0 (file-kind art-group)) + (format *file-temp-string* "$ART_GROUP/~S" arg1) + ) + ) + *file-temp-string* + ) + +(defun file-info-correct-version? ((arg0 file-info) (arg1 file-kind) (arg2 int)) + (let* ((s5-0 (cond + ((zero? arg2) + (case arg1 + (((file-kind tpage) (file-kind dir-tpage)) + 8 + ) + (((file-kind level-bt)) + 36 + ) + (((file-kind art-group)) + 7 + ) + ) + ) + (else + arg2 + ) + ) + ) + (v1-1 arg1) + (s4-0 (cond + ((= v1-1 (file-kind tpage)) + "texture-page" + ) + ((= v1-1 (file-kind level-bt)) + "bsp-header" + ) + ((= v1-1 (file-kind art-group)) + "art-group" + ) + ) + ) + ) + (cond + ((not (name= (-> arg0 file-type 0) s4-0)) + (format 0 "ERROR: file ~A is of type ~S but needs to be ~S.~%" (-> arg0 file-name) (-> arg0 file-type) s4-0) + #f + ) + ((!= s5-0 (-> arg0 major-version)) + (format + 0 + "ERROR: file ~A is version ~D.~D, but needs to be ~D.x~%" + (-> arg0 file-name) + (-> arg0 major-version) + (-> arg0 minor-version) + s5-0 + ) + #f + ) + (else + #t + ) + ) + ) + ) + + + + diff --git a/goal_src/jak2/engine/load/loader-h.gc b/goal_src/jak2/engine/load/loader-h.gc index 5165ee5a01..b4faf11a66 100644 --- a/goal_src/jak2/engine/load/loader-h.gc +++ b/goal_src/jak2/engine/load/loader-h.gc @@ -5,3 +5,216 @@ ;; name in dgo: loader-h ;; dgos: ENGINE, GAME +(declare-type art-group basic) +(define-extern art-group type) + +(define-extern external-art-buffer-init function) + +(deftype load-dir (basic) + ((lev level :offset-assert 4) + (string-array (array string) :offset-assert 8) + (data-array (array basic) :offset-assert 12) + ) + :method-count-assert 11 + :size-assert #x10 + :flag-assert #xb00000010 + (:methods + (new (symbol type int level) _type_ 0) + (dummy-9 () none 9) + (dummy-10 () none 10) + ) + ) + +(deftype load-dir-art-group (load-dir) + ((art-group-array (array art-group) :offset 12) + ) + :method-count-assert 11 + :size-assert #x10 + :flag-assert #xb00000010 + (:methods + (new (symbol type int level) _type_ 0) + ) + ) + +(defmethod new load-dir ((allocation symbol) (type-to-make type) (arg0 int) (arg1 level)) + (let ((s4-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (set! (-> s4-0 lev) arg1) + (set! (-> s4-0 string-array) + (the-as (array string) ((method-of-type array new) allocation array string arg0)) + ) + (set! (-> s4-0 string-array length) 0) + (set! (-> s4-0 data-array) (the-as (array basic) ((method-of-type array new) allocation array basic arg0))) + (set! (-> s4-0 data-array length) 0) + s4-0 + ) + ) + +(defmethod new load-dir-art-group ((allocation symbol) (type-to-make type) (arg0 int) (arg1 level)) + (let ((v0-0 ((method-of-type load-dir new) allocation type-to-make arg0 arg1))) + (set! (-> v0-0 data-array content-type) art-group) + (the-as load-dir-art-group v0-0) + ) + ) + +(deftype external-art-buffer (basic) + ((index int32 :offset-assert 4) + (other external-art-buffer :offset-assert 8) + (status symbol :offset-assert 12) + (locked? symbol :offset-assert 16) + (login? symbol :offset-assert 20) + (frame-lock symbol :offset-assert 24) + (init-heap function :offset-assert 28) + (heap kheap :inline :offset-assert 32) + (pending-load-file string :offset-assert 48) + (pending-load-file-part int32 :offset-assert 52) + (pending-load-file-owner handle :offset-assert 56) + (pending-load-file-priority float :offset-assert 64) + (load-file string :offset-assert 68) + (load-file-part int32 :offset-assert 72) + (load-file-owner handle :offset-assert 80) + (load-file-priority float :offset-assert 88) + (buf pointer :offset-assert 92) + (len int32 :offset-assert 96) + (art-group art-group :offset-assert 100) + (art-data uint32 :offset 100) + ) + :method-count-assert 16 + :size-assert #x68 + :flag-assert #x1000000068 + (:methods + (new (symbol type int function symbol) _type_ 0) + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + ) + ) + +(defmethod new external-art-buffer ((allocation symbol) (type-to-make type) (arg0 int) (arg1 function) (arg2 symbol)) + (let ((v0-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (set! (-> v0-0 index) arg0) + (set! (-> v0-0 init-heap) arg1) + (set! (-> v0-0 login?) arg2) + (set! (-> v0-0 load-file) #f) + (set! (-> v0-0 load-file-part) -1) + (set! (-> v0-0 load-file-owner) (the-as handle #f)) + (set! (-> v0-0 load-file-priority) 100000000.0) + (set! (-> v0-0 pending-load-file) #f) + (set! (-> v0-0 pending-load-file-part) -1) + (set! (-> v0-0 pending-load-file-owner) (the-as handle #f)) + (set! (-> v0-0 pending-load-file-priority) 100000000.0) + (set! (-> v0-0 art-group) #f) + (set! (-> v0-0 status) 'initialize) + (set! (-> v0-0 locked?) #f) + (set! (-> v0-0 other) #f) + v0-0 + ) + ) + +(deftype spool-anim (basic) + ((name string :offset 16) + (anim-name basic :offset-assert 20) + (parts int32 :offset-assert 24) + (hint-id int32 :offset 24) + (priority float :offset-assert 28) + (owner uint64 :offset-assert 32) + (command-list pair :offset-assert 40) + ) + :method-count-assert 9 + :size-assert #x2c + :flag-assert #x90000002c + ) + +(deftype external-art-control (basic) + ((buffer external-art-buffer 2 :offset-assert 4) + (rec spool-anim 3 :inline :offset-assert 16) + (spool-lock handle :offset-assert 160) + (reserve-buffer external-art-buffer :offset-assert 168) + (reserve-buffer-count int16 :offset-assert 172) + (dma-reserve-buffer-count int16 :offset-assert 174) + (active-stream string :offset-assert 176) + (queue-stream (array spool-anim) :offset-assert 180) + (frame-mask uint32 :offset-assert 184) + (dma-reserve-heap kheap :inline :offset-assert 192) + ) + :method-count-assert 16 + :size-assert #xd0 + :flag-assert #x10000000d0 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + ) + ) + + +(defmethod new external-art-control ((allocation symbol) (type-to-make type)) + (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (dotimes (s4-0 2) + (set! (-> gp-0 buffer s4-0) + ((method-of-type external-art-buffer new) allocation external-art-buffer s4-0 external-art-buffer-init #t) + ) + ) + (set! (-> gp-0 buffer 0 other) (-> gp-0 buffer 1)) + (set! (-> gp-0 buffer 1 other) (-> gp-0 buffer 0)) + (dotimes (v1-9 3) + (set! (-> gp-0 rec v1-9 name) #f) + (set! (-> gp-0 rec v1-9 priority) 100000000.0) + (set! (-> gp-0 rec v1-9 owner) (the-as uint #f)) + ) + (set! (-> gp-0 spool-lock) (the-as handle #f)) + (set! (-> gp-0 reserve-buffer) #f) + (set! (-> gp-0 active-stream) #f) + (set! (-> gp-0 queue-stream) (the-as (array spool-anim) (new 'global 'boxed-array spool-anim 4))) + (dotimes (s5-1 (-> gp-0 queue-stream allocated-length)) + (set! (-> gp-0 queue-stream s5-1) (new 'global 'spool-anim)) + ) + (set! (-> gp-0 queue-stream length) 0) + gp-0 + ) + ) + +(deftype subtitle-range (basic) + ((start-frame float :offset-assert 4) + (end-frame float :offset-assert 8) + (message object 8 :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x2c + :flag-assert #x90000002c + ) + +(defmethod inspect subtitle-range ((obj subtitle-range)) + (when (not obj) + (return obj) + ) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~1Tstart-frame: ~f~%" (-> obj start-frame)) + (format #t "~1Tend-frame: ~f~%" (-> obj end-frame)) + (format #t "~1Tmessage[8] @ #x~X~%" (-> obj message)) + (dotimes (s5-0 8) + (format #t "~T [~D]~1Tmessage: ~`object`P~%" s5-0 (-> obj message s5-0)) + ) + obj + ) + +(deftype subtitle-image (basic) + ((width uint16 :offset-assert 4) + (height uint16 :offset-assert 6) + (palette rgba 16 :offset 16) + (data uint8 :dynamic :offset-assert 80) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) + + + diff --git a/goal_src/jak2/engine/math/euler.gc b/goal_src/jak2/engine/math/euler.gc index da8b5b2afa..c0cf715bc7 100644 --- a/goal_src/jak2/engine/math/euler.gc +++ b/goal_src/jak2/engine/math/euler.gc @@ -5,3 +5,207 @@ ;; name in dgo: euler ;; dgos: ENGINE, GAME +(defun set-eul! ((arg0 euler-angles) (arg1 float) (arg2 float) (arg3 float) (arg4 int)) + (set! (-> arg0 x) arg1) + (set! (-> arg0 y) arg2) + (set! (-> arg0 z) arg3) + (set! (-> arg0 w) (the float arg4)) + arg0 + ) + +(defun eul->matrix ((arg0 matrix) (arg1 euler-angles)) + (matrix-identity! arg0) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (set! (-> s5-0 quad) (-> arg1 quad)) + (when (= (logand (the int (-> s5-0 w)) 1) 1) + (let ((f0-2 (-> s5-0 x))) + (set! (-> s5-0 x) (-> s5-0 z)) + (set! (-> s5-0 z) f0-2) + ) + ) + (when (= (logand (/ (the int (-> s5-0 w)) 4) 1) 1) + (set! (-> s5-0 x) (- (-> s5-0 x))) + (set! (-> s5-0 y) (- (-> s5-0 y))) + (set! (-> s5-0 z) (- (-> s5-0 z))) + ) + (let* ((f26-0 (cos (-> s5-0 x))) + (f30-0 (cos (-> s5-0 y))) + (f22-0 (cos (-> s5-0 z))) + (f24-0 (sin (-> s5-0 x))) + (f28-0 (sin (-> s5-0 y))) + (f4-0 (sin (-> s5-0 z))) + (f0-17 (* f26-0 f22-0)) + (f1-1 (* f26-0 f4-0)) + (f2-0 (* f24-0 f22-0)) + (f3-0 (* f24-0 f4-0)) + ) + 0 + 0 + 0 + (let* ((v1-12 (logand (/ (the int (-> s5-0 w)) 4) 1)) + (a1-2 (-> EulSafe (logand (/ (the int (-> s5-0 w)) 8) 3))) + (a0-21 (-> EulNext (+ a1-2 v1-12))) + (v1-17 (-> EulNext (+ (- 1 v1-12) a1-2))) + ) + (cond + ((= (logand (/ (the int (-> s5-0 w)) 2) 1) 1) + (set! (-> (the-as (pointer float) (+ (+ (* a1-2 16) (* a1-2 4)) (the-as int arg0)))) f30-0) + (set! (-> (the-as (pointer float) (+ (+ (* a1-2 16) (* a0-21 4)) (the-as int arg0)))) (* f28-0 f24-0)) + (set! (-> (the-as (pointer float) (+ (+ (* a1-2 16) (* v1-17 4)) (the-as int arg0)))) (* f28-0 f26-0)) + (set! (-> (the-as (pointer float) (+ (+ (* a0-21 16) (* a1-2 4)) (the-as int arg0)))) (* f28-0 f4-0)) + (set! (-> (the-as (pointer float) (+ (+ (* a0-21 16) (* a0-21 4)) (the-as int arg0)))) + (- f0-17 (* f30-0 f3-0)) + ) + (set! (-> (the-as (pointer float) (+ (+ (* a0-21 16) (* v1-17 4)) (the-as int arg0)))) + (- (- f2-0) (* f30-0 f1-1)) + ) + (set! (-> (the-as (pointer float) (+ (+ (* v1-17 16) (* a1-2 4)) (the-as int arg0)))) (- (* f28-0 f22-0))) + (set! (-> (the-as (pointer float) (+ (+ (* v1-17 16) (* a0-21 4)) (the-as int arg0)))) + (+ f1-1 (* f30-0 f2-0)) + ) + (set! (-> (the-as (pointer float) (+ (+ (* v1-17 16) (* v1-17 4)) (the-as int arg0)))) + (+ (- f3-0) (* f30-0 f0-17)) + ) + ) + (else + (set! (-> (the-as (pointer float) (+ (+ (* a1-2 16) (* a1-2 4)) (the-as int arg0)))) (* f30-0 f22-0)) + (set! (-> (the-as (pointer float) (+ (+ (* a1-2 16) (* a0-21 4)) (the-as int arg0)))) + (+ (- f1-1) (* f28-0 f2-0)) + ) + (set! (-> (the-as (pointer float) (+ (+ (* a1-2 16) (* v1-17 4)) (the-as int arg0)))) + (+ f3-0 (* f28-0 f0-17)) + ) + (set! (-> (the-as (pointer float) (+ (+ (* a0-21 16) (* a1-2 4)) (the-as int arg0)))) (* f30-0 f4-0)) + (set! (-> (the-as (pointer float) (+ (+ (* a0-21 16) (* a0-21 4)) (the-as int arg0)))) + (+ f0-17 (* f28-0 f3-0)) + ) + (set! (-> (the-as (pointer float) (+ (+ (* a0-21 16) (* v1-17 4)) (the-as int arg0)))) + (+ (- f2-0) (* f28-0 f1-1)) + ) + (set! (-> (the-as (pointer float) (+ (+ (* v1-17 16) (* a1-2 4)) (the-as int arg0)))) (- f28-0)) + (set! (-> (the-as (pointer float) (+ (+ (* v1-17 16) (* a0-21 4)) (the-as int arg0)))) (* f30-0 f24-0)) + (set! (-> (the-as (pointer float) (+ (+ (* v1-17 16) (* v1-17 4)) (the-as int arg0)))) (* f30-0 f26-0)) + ) + ) + ) + ) + ) + arg0 + ) + +(defun matrix->eul ((arg0 euler-angles) (arg1 matrix) (arg2 int)) + 0 + 0 + 0 + (let* ((v1-4 (logand (/ arg2 4) 1)) + (s3-0 (-> EulSafe (logand (/ arg2 8) 3))) + (s2-0 (-> EulNext (+ s3-0 v1-4))) + (s1-0 (-> EulNext (+ (- 1 v1-4) s3-0))) + ) + (cond + ((= (logand (/ arg2 2) 1) 1) + (let* ((f0-0 (-> (the-as (pointer float) (+ (+ (* s2-0 4) (* s3-0 16)) (the-as int arg1))))) + (f0-2 (* f0-0 f0-0)) + (f1-0 (-> (the-as (pointer float) (+ (+ (* s1-0 4) (* s3-0 16)) (the-as int arg1))))) + (f30-0 (sqrtf (+ f0-2 (* f1-0 f1-0)))) + ) + (cond + ((< 0.00000000001 f30-0) + (set! (-> arg0 x) (atan + (-> (the-as (pointer float) (+ (+ (* s2-0 4) (* s3-0 16)) (the-as int arg1)))) + (-> (the-as (pointer float) (+ (+ (* s1-0 4) (* s3-0 16)) (the-as int arg1)))) + ) + ) + (set! (-> arg0 y) (atan f30-0 (-> (the-as (pointer float) (+ (+ (* s3-0 4) (* s3-0 16)) (the-as int arg1)))))) + (set! (-> arg0 z) (atan + (-> (the-as (pointer float) (+ (+ (* s3-0 4) (* s2-0 16)) (the-as int arg1)))) + (- (-> (the-as (pointer float) (+ (+ (* s3-0 4) (* s1-0 16)) (the-as int arg1))))) + ) + ) + ) + (else + (set! (-> arg0 x) (atan + (- (-> (the-as (pointer float) (+ (+ (* s1-0 4) (* s2-0 16)) (the-as int arg1))))) + (-> (the-as (pointer float) (+ (+ (* s2-0 4) (* s2-0 16)) (the-as int arg1)))) + ) + ) + (set! (-> arg0 y) (atan f30-0 (-> (the-as (pointer float) (+ (+ (* s3-0 4) (* s3-0 16)) (the-as int arg1)))))) + (set! (-> arg0 z) 0.0) + ) + ) + ) + ) + (else + (let* ((f0-21 (-> (the-as (pointer float) (+ (+ (* s3-0 4) (* s3-0 16)) (the-as int arg1))))) + (f0-23 (* f0-21 f0-21)) + (f1-3 (-> (the-as (pointer float) (+ (+ (* s3-0 4) (* s2-0 16)) (the-as int arg1))))) + (f30-1 (sqrtf (+ f0-23 (* f1-3 f1-3)))) + ) + (cond + ((< 0.00000000001 f30-1) + (set! (-> arg0 x) + (atan + (-> (the-as (pointer float) (+ (+ (* s2-0 4) (* s1-0 16)) (the-as int arg1)))) + (-> (the-as (pointer float) (+ (+ (* s1-0 4) (* s1-0 16)) (the-as int arg1)))) + ) + ) + (set! (-> arg0 y) + (atan (- (-> (the-as (pointer float) (+ (+ (* s3-0 4) (* s1-0 16)) (the-as int arg1))))) f30-1) + ) + (set! (-> arg0 z) (atan + (-> (the-as (pointer float) (+ (+ (* s3-0 4) (* s2-0 16)) (the-as int arg1)))) + (-> (the-as (pointer float) (+ (+ (* s3-0 4) (* s3-0 16)) (the-as int arg1)))) + ) + ) + ) + (else + (set! (-> arg0 x) + (atan + (- (-> (the-as (pointer float) (+ (+ (* s1-0 4) (* s2-0 16)) (the-as int arg1))))) + (-> (the-as (pointer float) (+ (+ (* s2-0 4) (* s2-0 16)) (the-as int arg1)))) + ) + ) + (set! (-> arg0 y) + (atan (- (-> (the-as (pointer float) (+ (+ (* s3-0 4) (* s1-0 16)) (the-as int arg1))))) f30-1) + ) + (set! (-> arg0 z) 0.0) + ) + ) + ) + ) + ) + ) + (when (= (logand (/ arg2 4) 1) 1) + (set! (-> arg0 x) (- (-> arg0 x))) + (set! (-> arg0 y) (- (-> arg0 y))) + (set! (-> arg0 z) (- (-> arg0 z))) + ) + (when (= (logand arg2 1) 1) + (let ((f0-49 (-> arg0 x))) + (set! (-> arg0 x) (-> arg0 z)) + (set! (-> arg0 z) f0-49) + ) + ) + (set! (-> arg0 w) (the float arg2)) + arg0 + ) + +(defun eul->quat ((arg0 quaternion) (arg1 euler-angles)) + (let ((s5-0 (new 'stack-no-clear 'matrix))) + (eul->matrix s5-0 arg1) + (matrix->quaternion arg0 s5-0) + ) + arg0 + ) + +(defun quat->eul ((arg0 euler-angles) (arg1 quaternion) (arg2 int)) + (let ((s5-0 (new 'stack-no-clear 'matrix))) + (quaternion->matrix s5-0 arg1) + (matrix->eul arg0 s5-0 arg2) + ) + arg0 + ) + + + + diff --git a/goal_src/jak2/engine/math/matrix-h.gc b/goal_src/jak2/engine/math/matrix-h.gc index 9ead40f84c..2f1d11d029 100644 --- a/goal_src/jak2/engine/math/matrix-h.gc +++ b/goal_src/jak2/engine/math/matrix-h.gc @@ -52,3 +52,14 @@ ) arg0 ) + +(defmacro new-stack-matrix0 () + "Get a new matrix on the stack that's set to zero." + `(let ((mat (new 'stack-no-clear 'matrix))) + (set! (-> mat quad 0) (the-as uint128 0)) + (set! (-> mat quad 1) (the-as uint128 0)) + (set! (-> mat quad 2) (the-as uint128 0)) + (set! (-> mat quad 3) (the-as uint128 0)) + mat + ) + ) \ No newline at end of file diff --git a/goal_src/jak2/engine/math/quaternion-h.gc b/goal_src/jak2/engine/math/quaternion-h.gc index ea3f3464db..996e21da64 100644 --- a/goal_src/jak2/engine/math/quaternion-h.gc +++ b/goal_src/jak2/engine/math/quaternion-h.gc @@ -21,6 +21,17 @@ (define *unity-quaternion* (new 'static 'quaternion :data (new 'static 'array float 4 0.0 0.0 0.0 1.0))) +(define-extern quaternion-normalize! (function quaternion quaternion)) (define-extern quaternion->matrix (function matrix quaternion matrix)) (define-extern matrix->quaternion (function quaternion matrix quaternion)) (define-extern vector-y-angle (function vector float)) + +(defmacro new-stack-quaternion0 () + "Get a stack quaternion that's set to 0. + This is more efficient than (new 'stack 'quaternion) because + this doesn't call the constructor." + `(let ((q (new 'stack-no-clear 'quaternion))) + (set! (-> q quad) (the-as uint128 0)) + q + ) + ) diff --git a/goal_src/jak2/engine/math/quaternion.gc b/goal_src/jak2/engine/math/quaternion.gc index 3932bb6662..c4adee9462 100644 --- a/goal_src/jak2/engine/math/quaternion.gc +++ b/goal_src/jak2/engine/math/quaternion.gc @@ -5,3 +5,990 @@ ;; name in dgo: quaternion ;; dgos: ENGINE, GAME +(defmethod inspect quaternion ((obj quaternion)) + (format #t "[~8x] quaternion~%" obj) + (format #t "~T[~F] [~F] [~F] [~F]~%" (-> obj x) (-> obj y) (-> obj z) (-> obj w)) + (let ((f0-5 (/ 1.0 (sqrtf (+ (* (-> obj x) (-> obj x)) (* (-> obj y) (-> obj y)) (* (-> obj z) (-> obj z))))))) + (format #t "~Taxis: ~F ~F ~F" (* f0-5 (-> obj x)) (* f0-5 (-> obj y)) (* f0-5 (-> obj z))) + ) + (let ((f0-9 (* 2.0 (acos (-> obj w))))) + (format #t "~T~Tangle: (deg ~R)~%" f0-9) + ) + obj + ) + +(defun quaternion-axis-angle! ((arg0 quaternion) (arg1 float) (arg2 float) (arg3 float) (arg4 float)) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (sincos! (the-as (pointer float) s5-0) (* 0.5 arg4)) + (let ((f0-2 (-> s5-0 x))) + (set! (-> arg0 x) (* arg1 f0-2)) + (set! (-> arg0 y) (* arg2 f0-2)) + (set! (-> arg0 z) (* arg3 f0-2)) + ) + (set! (-> arg0 w) (-> s5-0 y)) + ) + arg0 + ) + +(defun quaternion-vector-angle! ((arg0 quaternion) (arg1 vector) (arg2 float)) + (let ((s5-0 (new 'stack-no-clear 'vector))) + (sincos! (the-as (pointer float) s5-0) (* 0.5 arg2)) + (let ((f0-2 (-> s5-0 x))) + (set! (-> arg0 x) (* (-> arg1 x) f0-2)) + (set! (-> arg0 y) (* (-> arg1 y) f0-2)) + (set! (-> arg0 z) (* (-> arg1 z) f0-2)) + ) + (set! (-> arg0 w) (-> s5-0 y)) + ) + arg0 + ) + +(defun vector-angle<-quaternion! ((arg0 vector) (arg1 quaternion)) + (let* ((f0-0 1.0) + (f1-0 1.0) + (f2-0 (-> arg1 w)) + (f30-0 (/ f0-0 (sqrtf (- f1-0 (* f2-0 f2-0))))) + (f0-3 (* 2.0 (acos-rad (-> arg1 w)))) + ) + (set! (-> arg0 x) (* (-> arg1 x) f30-0)) + (set! (-> arg0 y) (* (-> arg1 y) f30-0)) + (set! (-> arg0 z) (* (-> arg1 z) f30-0)) + (set! (-> arg0 w) f0-3) + ) + arg0 + ) + +(defun quaternion-look-at! ((arg0 vector) (arg1 vector) (arg2 vector)) + (let ((s5-0 (new 'stack-no-clear 'matrix))) + (vector-cross! (the-as vector (-> s5-0 data)) arg2 arg1) + (vector-cross! (the-as vector (&-> s5-0 data 4)) arg1 (the-as vector (-> s5-0 data))) + (set! (-> s5-0 vector 2 quad) (-> arg1 quad)) + (quaternion-normalize! (matrix->quaternion (the-as quaternion arg0) s5-0)) + ) + ) + +(defun quaternion-zero! ((arg0 quaternion)) + (set! (-> arg0 vec quad) (the-as uint128 0)) + arg0 + ) + +(defun quaternion-identity! ((arg0 quaternion)) + (set! (-> arg0 vec quad) (the-as uint128 0)) + (set! (-> arg0 w) 1.0) + arg0 + ) + +(defun quaternion-i! ((arg0 quaternion)) + (set! (-> arg0 vec quad) (the-as uint128 0)) + (set! (-> arg0 x) 1.0) + arg0 + ) + +(defun quaternion-j! ((arg0 quaternion)) + (set! (-> arg0 vec quad) (the-as uint128 0)) + (set! (-> arg0 y) 1.0) + arg0 + ) + +(defun quaternion-k! ((arg0 quaternion)) + (set! (-> arg0 vec quad) (the-as uint128 0)) + (set! (-> arg0 z) 1.0) + arg0 + ) + +(defun quaternion-copy! ((arg0 quaternion) (arg1 quaternion)) + (set! (-> arg0 vec quad) (-> arg1 vec quad)) + arg0 + ) + +(defun quaternion-set! ((arg0 quaternion) (arg1 float) (arg2 float) (arg3 float) (arg4 float)) + (set! (-> arg0 x) arg1) + (set! (-> arg0 y) arg2) + (set! (-> arg0 z) arg3) + (set! (-> arg0 w) arg4) + arg0 + ) + +(defun quaternion+! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + ) + (.lvf vf1 (&-> arg1 vec quad)) + (.lvf vf2 (&-> arg2 vec quad)) + (.add.vf vf1 vf1 vf2) + (.svf (&-> arg0 vec quad) vf1) + arg0 + ) + ) + +(defun quaternion-! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + ) + (.lvf vf1 (&-> arg1 vec quad)) + (.lvf vf2 (&-> arg2 vec quad)) + (.sub.vf vf1 vf1 vf2) + (.svf (&-> arg0 vec quad) vf1) + arg0 + ) + ) + +(defun quaternion-negate! ((arg0 quaternion) (arg1 quaternion)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + ) + (.lvf vf1 (&-> arg1 vec quad)) + ;;(.sub.vf vf2 vf2 vf2) + (.xor.vf vf2 vf2 vf2) + (.sub.vf vf1 vf2 vf1) + (.svf (&-> arg0 vec quad) vf1) + arg0 + ) + ) + +(defun quaternion-conjugate! ((arg0 quaternion) (arg1 quaternion)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + ) + (.lvf vf1 (&-> arg1 vec quad)) + ;;(.sub.vf vf2 vf2 vf2) + (.xor.vf vf2 vf2 vf2) + (.sub.vf vf2 vf2 vf1 :mask #b111) + (.add.vf vf2 vf2 vf1 :mask #b1000) + (.svf (&-> arg0 vec quad) vf2) + arg0 + ) + ) + +(defun quaternion-float*! ((arg0 quaternion) (arg1 quaternion) (arg2 float)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + ) + (.lvf vf1 (&-> arg1 vec quad)) + (.mov vf2 arg2) + (.mul.x.vf vf1 vf1 vf2) + (.svf (&-> arg0 vec quad) vf1) + arg0 + ) + ) + +(defun quaternion-float/! ((arg0 quaternion) (arg1 quaternion) (arg2 float)) + (let ((f0-1 (/ 1.0 arg2))) + (quaternion-float*! arg0 arg1 f0-1) + ) + arg0 + ) + +(defun quaternion-norm2 ((arg0 quaternion)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 vec quad)) + (.mul.vf vf1 vf1 vf1) + (.add.z.vf acc vf1 vf1 :mask #b1000) + (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000) + (.add.mul.x.vf vf1 vf0 vf1 acc :mask #b1000) + (.add.w.vf vf1 vf0 vf1) + (.mov v0-0 vf1) + v0-0 + ) + ) + +(defun quaternion-norm ((arg0 quaternion)) + (local-vars (v1-1 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 vec quad)) + (.mul.vf vf1 vf1 vf1) + (.add.z.vf acc vf1 vf1 :mask #b1000) + (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000) + (.add.mul.x.vf vf1 vf0 vf1 acc :mask #b1000) + (.add.w.vf vf1 vf0 vf1) + (.mov v1-1 vf1) + (sqrtf v1-1) + ) + ) + +(defun quaternion-normalize! ((arg0 quaternion)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 vec quad)) + (.mul.vf vf2 vf1 vf1) + (.add.z.vf acc vf2 vf2 :mask #b1000) + (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000) + (.add.mul.x.vf vf2 vf0 vf2 acc :mask #b1000) + (.isqrt.vf Q vf0 vf2 :fsf #b11 :ftf #b11) + (.wait.vf) + (.mul.vf vf2 vf1 Q) + (.nop.vf) + (.nop.vf) + (.svf (&-> arg0 vec quad) vf2) + arg0 + ) + ) + +(defun quaternion-inverse! ((arg0 quaternion) (arg1 quaternion)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 vec quad)) + (.mul.vf vf2 vf1 vf1) + (.xor.vf vf3 vf3 vf3) + ;;(.sub.vf vf3 vf3 vf3) + (.add.z.vf acc vf2 vf2 :mask #b1000) + (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000) + (.add.mul.x.vf vf2 vf0 vf2 acc :mask #b1000) + (.sub.vf vf3 vf3 vf1 :mask #b111) + (.div.vf Q vf0 vf2 :fsf #b11 :ftf #b11) + (.add.vf vf3 vf3 vf1 :mask #b1000) + (.wait.vf) + (.mul.vf vf3 vf3 Q) + (.nop.vf) + (.nop.vf) + (.svf (&-> arg0 vec quad) vf3) + arg0 + ) + ) + +(defun quaternion-dot ((arg0 quaternion) (arg1 quaternion)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 vec quad)) + (.lvf vf2 (&-> arg1 vec quad)) + (.mul.vf vf1 vf1 vf2) + (.add.z.vf acc vf1 vf1 :mask #b1000) + (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000) + (.add.mul.x.vf vf1 vf0 vf1 acc :mask #b1000) + (.add.w.vf vf1 vf0 vf1) + (.mov v0-0 vf1) + v0-0 + ) + ) + +;; definition for function quaternion*! +(defun quaternion*! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 vec quad)) + (.lvf vf2 (&-> arg2 vec quad)) + (.sub.vf vf4 vf0 vf0 :mask #b1000) + (.mul.vf vf3 vf1 vf2) + (.outer.product.a.vf acc vf1 vf2) + (.outer.product.b.vf vf4 vf2 vf1 acc) + (.mul.w.vf acc vf1 vf2) + (.add.mul.w.vf acc vf2 vf1 acc) + (.sub.mul.w.vf acc vf0 vf3 acc :mask #b1000) + (.sub.mul.z.vf acc vf0 vf3 acc :mask #b1000) + (.sub.mul.y.vf acc vf0 vf3 acc :mask #b1000) + (.sub.mul.x.vf acc vf0 vf3 acc :mask #b1000) + (.add.mul.w.vf vf1 vf4 vf0 acc) + (.svf (&-> arg0 vec quad) vf1) + arg0 + ) + ) + +(defun quaternion-right-mult-matrix! ((arg0 matrix) (arg1 quaternion)) + (let ((f3-0 (-> arg1 x)) + (f2-0 (-> arg1 y)) + (f1-0 (-> arg1 z)) + (f0-0 (-> arg1 w)) + ) + (set! (-> arg0 data 0) f0-0) + (set! (-> arg0 data 1) f1-0) + (set! (-> arg0 data 2) (- f2-0)) + (set! (-> arg0 data 3) f3-0) + (set! (-> arg0 data 4) (- f1-0)) + (set! (-> arg0 data 5) f0-0) + (set! (-> arg0 data 6) f3-0) + (set! (-> arg0 data 7) f2-0) + (set! (-> arg0 data 8) f2-0) + (set! (-> arg0 data 9) (- f3-0)) + (set! (-> arg0 data 10) f0-0) + (set! (-> arg0 data 11) f1-0) + (set! (-> arg0 trans x) (- f3-0)) + (set! (-> arg0 trans y) (- f2-0)) + (set! (-> arg0 trans z) (- f1-0)) + (set! (-> arg0 trans w) f0-0) + ) + arg0 + ) + +(defun quaternion-left-mult-matrix! ((arg0 matrix) (arg1 quaternion)) + (let ((f2-0 (-> arg1 x)) + (f1-0 (-> arg1 y)) + (f0-0 (-> arg1 z)) + ) + (let ((f3-0 (-> arg1 w))) + (set! (-> arg0 data 0) f2-0) + (set! (-> arg0 data 1) f3-0) + (set! (-> arg0 data 2) (- f0-0)) + (set! (-> arg0 data 3) f1-0) + (set! (-> arg0 data 4) f1-0) + (set! (-> arg0 data 5) f0-0) + (set! (-> arg0 data 6) f3-0) + (set! (-> arg0 data 7) (- f3-0)) + (set! (-> arg0 data 8) f0-0) + (set! (-> arg0 data 9) (- f1-0)) + (set! (-> arg0 data 10) f2-0) + (set! (-> arg0 data 11) f3-0) + (set! (-> arg0 trans x) f3-0) + ) + (set! (-> arg0 trans y) (- f2-0)) + (set! (-> arg0 trans z) (- f1-0)) + (set! (-> arg0 trans w) (- f0-0)) + ) + arg0 + ) + +(defun quaternion->matrix ((arg0 matrix) (arg1 quaternion)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 vec quad)) + (.add.vf vf5 vf1 vf1) + (.add.w.vf vf2 vf0 vf1 :mask #b1) + (.add.z.vf vf2 vf0 vf1 :mask #b10) + (.sub.y.vf vf2 vf0 vf1 :mask #b100) + (.sub.w.vf vf2 vf0 vf0 :mask #b1000) + (.sub.z.vf vf3 vf0 vf1 :mask #b1) + (.add.w.vf vf3 vf0 vf1 :mask #b10) + (.add.x.vf vf3 vf0 vf1 :mask #b100) + (.sub.w.vf vf3 vf0 vf0 :mask #b1000) + (.add.y.vf vf4 vf0 vf1 :mask #b1) + (.sub.x.vf vf4 vf0 vf1 :mask #b10) + (.add.w.vf vf4 vf0 vf1 :mask #b100) + (.sub.w.vf vf4 vf0 vf0 :mask #b1000) + (.outer.product.a.vf acc vf5 vf2) + (.outer.product.b.vf vf2 vf2 vf5 acc) + (.outer.product.a.vf acc vf5 vf3) + (.outer.product.b.vf vf3 vf3 vf5 acc) + (.outer.product.a.vf acc vf5 vf4) + (.outer.product.b.vf vf4 vf4 vf5 acc) + (.add.w.vf vf2 vf2 vf0 :mask #b1) + (.add.w.vf vf3 vf3 vf0 :mask #b10) + (.add.w.vf vf4 vf4 vf0 :mask #b100) + (.svf (&-> arg0 trans quad) vf0) + (.svf (&-> arg0 quad 0) vf2) + (.svf (&-> arg0 quad 1) vf3) + (.svf (&-> arg0 quad 2) vf4) + arg0 + ) + ) + +#| +;; definition for function quaternion->matrix-2 +;; WARN: Unsupported inline assembly instruction kind - [pexew a1, v1] +;; WARN: Unsupported inline assembly instruction kind - [prot3w a2, a1] +;; Used lq/sq +(defun quaternion->matrix-2 ((arg0 matrix) (arg1 quaternion)) + (local-vars (v1-1 uint128) (a1-1 uint128) (a1-2 uint128) (a2-0 uint128) (a3-0 uint128)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + (vf8 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 (-> arg1 vec quad))) + (.pexew a1-1 v1-0) + (.mov vf1 v1-0) + (.prot3w a2-0 a1-1) + (.pcpyud a1-2 v1-0 a1-1) + (.mov vf4 a2-0) + (let ((a2-1 #x3f800000)) + (.add.vf vf5 vf1 vf1) + (.sub.y.vf vf4 vf0 vf4 :mask #b10) + (.pextlw a3-0 v1-0 a1-2) + (.mov vf3 a1-2) + (.pextuw v1-1 v1-0 a3-0) + (.mov vf2 v1-1) + (set! (-> arg0 trans quad) (the-as uint128 0)) + (.sub.x.vf vf3 vf0 vf3 :mask #b1) + (set! (-> arg0 trans w) (the-as float a2-1)) + (.sub.z.vf vf2 vf0 vf2 :mask #b100) + (.outer.product.a.vf acc vf5 vf4) + (.outer.product.b.vf vf8 vf4 vf5 acc) + (.outer.product.a.vf acc vf5 vf3) + (.outer.product.b.vf vf7 vf3 vf5 acc) + (.outer.product.a.vf acc vf5 vf2) + (.outer.product.b.vf vf6 vf2 vf5 acc) + (.add.w.vf vf8 vf8 vf0 :mask #b100) + (.add.w.vf vf7 vf7 vf0 :mask #b10) + (.add.w.vf vf6 vf6 vf0 :mask #b1) + (.svf (&-> arg0 quad 2) vf8) + (set! (-> arg0 data 11) (the-as float a2-1)) + (.svf (&-> arg0 quad 1) vf7) + (set! (-> arg0 data 7) (the-as float a2-1)) + (.svf (&-> arg0 quad 0) vf6) + (set! (-> arg0 data 3) (the-as float a2-1)) + ) + ) + arg0 + ) + ) +|# + +(defun matrix->quaternion ((arg0 quaternion) (arg1 matrix)) + (let ((f0-2 (+ (-> arg1 data 0) (-> arg1 data 5) (-> arg1 data 10)))) + (cond + ((< 0.0 f0-2) + (let ((f0-4 (sqrtf (+ 1.0 f0-2)))) + (set! (-> arg0 w) (* 0.5 f0-4)) + (let ((f0-5 (/ 0.5 f0-4))) + (set! (-> arg0 x) (* f0-5 (- (-> arg1 data 6) (-> arg1 data 9)))) + (set! (-> arg0 y) (* f0-5 (- (-> arg1 data 8) (-> arg1 data 2)))) + (set! (-> arg0 z) (* f0-5 (- (-> arg1 data 1) (-> arg1 data 4)))) + ) + ) + ) + (else + (let ((a2-0 0) + (a3-0 1) + (v1-4 2) + ) + (when (< (-> arg1 data 0) (-> arg1 data 5)) + (set! a2-0 1) + (set! a3-0 2) + (set! v1-4 0) + ) + (when (< (-> (the-as (pointer float) (+ (+ (* a2-0 4) (* a2-0 16)) (the-as int arg1)))) (-> arg1 data 10)) + (set! a2-0 2) + (set! a3-0 0) + (set! v1-4 1) + ) + (let ((f0-12 + (sqrtf + (+ (- 1.0 + (+ (-> (the-as (pointer float) (+ (+ (* a3-0 4) (* a3-0 16)) (the-as int arg1)))) + (-> (the-as (pointer float) (+ (+ (* v1-4 4) (* v1-4 16)) (the-as int arg1)))) + ) + ) + (-> (the-as (pointer float) (+ (+ (* a2-0 4) (* a2-0 16)) (the-as int arg1)))) + ) + ) + ) + ) + (set! (-> arg0 data a2-0) (* 0.5 f0-12)) + (if (!= f0-12 0.0) + (set! f0-12 (/ 0.5 f0-12)) + ) + (set! (-> arg0 w) + (* (- (-> (the-as (pointer float) (+ (+ (* v1-4 4) (* a3-0 16)) (the-as int arg1)))) + (-> (the-as (pointer float) (+ (+ (* a3-0 4) (* v1-4 16)) (the-as int arg1)))) + ) + f0-12 + ) + ) + (set! (-> arg0 data a3-0) + (* (+ (-> (the-as (pointer float) (+ (+ (* a3-0 4) (* a2-0 16)) (the-as int arg1)))) + (-> (the-as (pointer float) (+ (+ (* a2-0 4) (* a3-0 16)) (the-as int arg1)))) + ) + f0-12 + ) + ) + (set! (-> arg0 data v1-4) + (* (+ (-> (the-as (pointer float) (+ (+ (* v1-4 4) (* a2-0 16)) (the-as int arg1)))) + (-> (the-as (pointer float) (+ (+ (* a2-0 4) (* v1-4 16)) (the-as int arg1)))) + ) + f0-12 + ) + ) + ) + ) + ) + ) + ) + arg0 + ) + +(defun matrix-with-scale->quaternion ((arg0 quaternion) (arg1 matrix)) + (local-vars (a1-4 float)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (let ((v1-0 (new-stack-matrix0))) + (let* ((f0-1 (vector-dot (the-as vector (-> arg1 data)) (the-as vector (-> arg1 data)))) + (f1-1 (vector-dot (the-as vector (&-> arg1 data 4)) (the-as vector (&-> arg1 data 4)))) + (f2-1 (vector-dot (the-as vector (&-> arg1 data 8)) (the-as vector (&-> arg1 data 8)))) + (f0-3 (/ 1.0 (sqrtf f0-1))) + (f1-3 (/ 1.0 (sqrtf f1-1))) + (f2-3 (/ 1.0 (sqrtf f2-1))) + ) + (.lvf vf1 (&-> arg1 quad 0)) + (.lvf vf2 (&-> arg1 quad 1)) + (.lvf vf3 (&-> arg1 quad 2)) + (.lvf vf4 (&-> arg1 trans quad)) + (let ((a1-1 f0-3)) + (.mov vf5 a1-1) + ) + (let ((a1-2 f1-3)) + (.mov vf6 a1-2) + ) + (let ((a1-3 f2-3)) + (.mov vf7 a1-3) + ) + ) + (.mul.x.vf vf1 vf1 vf5) + (.mul.x.vf vf2 vf2 vf6) + (.mul.x.vf vf3 vf3 vf7) + (.svf (&-> v1-0 quad 0) vf1) + (.svf (&-> v1-0 quad 1) vf2) + (.svf (&-> v1-0 quad 2) vf3) + (.svf (&-> v1-0 trans quad) vf4) + (.mov a1-4 vf4) + (matrix->quaternion arg0 v1-0) + ) + ) + ) + +(defun quaternion-vector-len ((arg0 quaternion)) + (let ((f0-0 1.0) + (f1-0 (-> arg0 w)) + ) + (sqrtf (- f0-0 (* f1-0 f1-0))) + ) + ) + +(defun quaternion-log! ((arg0 quaternion) (arg1 quaternion)) + (cond + ((= (-> arg1 w) 0.0) + (set! (-> arg0 x) (* 1.5707963 (-> arg1 x))) + (set! (-> arg0 y) (* 1.5707963 (-> arg1 y))) + (set! (-> arg0 z) (* 1.5707963 (-> arg1 z))) + ) + (else + (let* ((f30-0 (quaternion-vector-len arg1)) + (f0-9 (/ (atan2-rad (-> arg1 w) f30-0) f30-0)) + ) + (set! (-> arg0 x) (* (-> arg1 x) f0-9)) + (set! (-> arg0 y) (* (-> arg1 y) f0-9)) + (set! (-> arg0 z) (* (-> arg1 z) f0-9)) + ) + ) + ) + arg0 + ) + +(defun quaternion-exp! ((arg0 quaternion) (arg1 quaternion)) + (let ((f30-0 (vector-length (the-as vector arg1)))) + (cond + ((= f30-0 0.0) + (set! (-> arg0 x) 0.0) + (set! (-> arg0 y) 0.0) + (set! (-> arg0 z) 0.0) + (set! (-> arg0 w) 1.0) + ) + (else + (let ((s5-0 (new 'stack-no-clear 'vector))) + (sincos-rad! (the-as (pointer float) s5-0) f30-0) + (let ((f0-6 (/ (-> s5-0 x) f30-0))) + (set! (-> arg0 x) (* (-> arg1 x) f0-6)) + (set! (-> arg0 y) (* (-> arg1 y) f0-6)) + (set! (-> arg0 z) (* (-> arg1 z) f0-6)) + ) + (set! (-> arg0 w) (-> s5-0 y)) + ) + ) + ) + ) + arg0 + ) + +(defun quaternion-slerp! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float)) + (local-vars (v1-15 float)) + (rlet ((acc :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (let ((f0-0 (quaternion-dot arg1 arg2)) + (f30-0 1.0) + ) + (when (< f0-0 0.0) + (set! f0-0 (- f0-0)) + (set! f30-0 -1.0) + ) + (cond + ((< (- 1.0 f0-0) 0.0001) + (let ((v1-7 (- 1.0 arg3))) + (.mov vf1 v1-7) + ) + (let ((v1-8 (* arg3 f30-0))) + (.mov vf2 v1-8) + ) + (.lvf vf3 (&-> arg1 vec quad)) + (.lvf vf4 (&-> arg2 vec quad)) + (.mul.x.vf acc vf3 vf1) + (.add.mul.x.vf vf3 vf4 vf2 acc) + (.svf (&-> arg0 vec quad) vf3) + (quaternion-normalize! arg0) + ) + (else + (let* ((f1-4 1.0) + (f2-1 f0-0) + (f1-6 (sqrtf (- f1-4 (* f2-1 f2-1)))) + (f0-6 (/ (- f1-6 f0-0) (+ f1-6 f0-0))) + (f28-0 (/ 1.0 f1-6)) + ) + (let ((f0-7 (atan-series-rad f0-6)) + (s2-0 (new 'stack-no-clear 'vector)) + ) + (set! (-> s2-0 x) (* (- 1.0 arg3) f0-7)) + (set! (-> s2-0 y) (* arg3 f0-7 f30-0)) + (vector-sin-rad! s2-0 s2-0) + (.lvf vf1 (&-> s2-0 quad)) + ) + (let ((v1-14 f28-0)) + (.mov vf2 v1-14) + ) + ) + (.mul.x.vf vf1 vf1 vf2) + (.lvf vf3 (&-> arg1 vec quad)) + (.lvf vf4 (&-> arg2 vec quad)) + (.mul.x.vf acc vf3 vf1) + (.add.mul.y.vf vf3 vf4 vf1 acc) + (.svf (&-> arg0 vec quad) vf3) + (.mov v1-15 vf3) + ) + ) + ) + arg0 + ) + ) + +(defun quaternion-pseudo-slerp! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float)) + (rlet ((acc :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (let ((f1-0 (quaternion-dot arg1 arg2)) + (f0-0 1.0) + ) + (when (< f1-0 0.0) + (- f1-0) + (set! f0-0 -1.0) + ) + (let ((v1-5 (- 1.0 arg3))) + (.mov vf1 v1-5) + ) + (let ((v1-6 (* arg3 f0-0))) + (.mov vf2 v1-6) + ) + ) + (.lvf vf3 (&-> arg1 vec quad)) + (.lvf vf4 (&-> arg2 vec quad)) + (.mul.x.vf acc vf3 vf1) + (.add.mul.x.vf vf3 vf4 vf2 acc) + (.svf (&-> arg0 vec quad) vf3) + (quaternion-normalize! arg0) + arg0 + ) + ) + +(defun quaternion-pseudo-seek ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float)) + (let ((s3-0 (new 'stack-no-clear 'quaternion))) + (let ((s5-0 (new 'stack-no-clear 'quaternion))) + (quaternion-copy! s3-0 arg2) + (if (< (quaternion-dot s3-0 arg1) 0.0) + (quaternion-negate! s3-0 s3-0) + ) + (quaternion-! s5-0 s3-0 arg1) + (let ((f0-1 (quaternion-norm2 s5-0)) + (f1-1 arg3) + ) + (if (< (* f1-1 f1-1) f0-1) + (quaternion-float*! s5-0 s5-0 (/ arg3 (sqrtf f0-1))) + ) + ) + (quaternion+! s3-0 arg1 s5-0) + ) + (quaternion-normalize! s3-0) + (quaternion-copy! arg0 s3-0) + ) + ) + +(defun quaternion-smooth-seek! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float)) + (let ((gp-0 (new 'stack-no-clear 'inline-array 'quaternion 2))) + (quaternion-copy! (-> gp-0 0) arg2) + (if (< (quaternion-dot (-> gp-0 0) arg1) 0.0) + (quaternion-negate! (-> gp-0 0) (-> gp-0 0)) + ) + (quaternion-! (-> gp-0 1) (-> gp-0 0) arg1) + (quaternion-float*! (-> gp-0 1) (-> gp-0 1) (fmin 1.0 arg3)) + (quaternion+! (-> gp-0 0) arg1 (-> gp-0 1)) + (quaternion-normalize! (-> gp-0 0)) + (quaternion-copy! arg0 (-> gp-0 0)) + ) + ) + +(defun quaternion-zxy! ((arg0 quaternion) (arg1 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (init-vf0-vector) + (let ((s4-0 (new 'stack-no-clear 'vector)) + (gp-0 (new 'stack-no-clear 'vector)) + (s5-0 (new 'stack-no-clear 'vector)) + ) + (vector-rad<-vector-deg/2! s4-0 arg1) + (vector-sincos-rad! gp-0 s5-0 s4-0) + (.lvf vf1 (&-> gp-0 quad)) + (.lvf vf2 (&-> s5-0 quad)) + ) + (.mul.x.vf vf4 vf0 vf1 :mask #b1000) + (.add.vf vf4 vf0 vf2 :mask #b111) + (.sub.vf vf4 vf0 vf4 :mask #b110) + (.add.vf vf3 vf0 vf1 :mask #b111) + (.mul.x.vf vf3 vf0 vf2 :mask #b1000) + (.outer.product.a.vf acc vf1 vf1) + (.outer.product.b.vf vf6 vf0 vf0 acc) + (.outer.product.a.vf acc vf2 vf2) + (.outer.product.b.vf vf5 vf0 vf0 acc) + (.mul.x.vf vf6 vf0 vf6 :mask #b1000) + (.mul.x.vf vf5 vf0 vf5 :mask #b1000) + (.mul.vf acc vf6 vf4) + (.add.mul.vf vf7 vf5 vf3 acc) + (.svf (&-> arg0 vec quad) vf7) + arg0 + ) + ) + +(defun vector-x-quaternion! ((arg0 vector) (arg1 quaternion)) + (let ((s5-0 (new-stack-matrix0))) + (quaternion->matrix s5-0 arg1) + (set! (-> arg0 quad) (-> (the-as (pointer uint128) (-> s5-0 data)) 0)) + ) + arg0 + ) + +(defun vector-y-quaternion! ((arg0 vector) (arg1 quaternion)) + (let ((s5-0 (new-stack-matrix0))) + (quaternion->matrix s5-0 arg1) + (set! (-> arg0 quad) (-> (the-as (pointer uint128) (&-> s5-0 data 4)) 0)) + ) + arg0 + ) + +(defun vector-z-quaternion! ((arg0 vector) (arg1 quaternion)) + (let ((s5-0 (new-stack-matrix0))) + (quaternion->matrix s5-0 arg1) + (set! (-> arg0 quad) (-> (the-as (pointer uint128) (&-> s5-0 data 8)) 0)) + ) + arg0 + ) + +(defun quaternion-x-angle ((arg0 quaternion)) + (let ((v1-1 (vector-y-quaternion! (new 'stack-no-clear 'vector) arg0))) + (atan (-> v1-1 z) (-> v1-1 y)) + ) + ) + +(defun quaternion-y-angle ((arg0 quaternion)) + (let ((v1-1 (vector-z-quaternion! (new 'stack-no-clear 'vector) arg0))) + (atan (-> v1-1 x) (-> v1-1 z)) + ) + ) + +(defun quaternion-z-angle ((arg0 quaternion)) + (let ((v1-1 (vector-y-quaternion! (new 'stack-no-clear 'vector) arg0))) + (atan (-> v1-1 x) (-> v1-1 y)) + ) + ) + +(defun quaternion-vector-y-angle ((arg0 quaternion) (arg1 vector)) + (let ((f30-0 (quaternion-y-angle arg0)) + (f0-2 (atan (-> arg1 x) (-> arg1 z))) + ) + (deg-diff f30-0 f0-2) + ) + ) + +(defun quaternion-rotate-local-x! ((arg0 quaternion) (arg1 quaternion) (arg2 float)) + (let ((a2-1 (quaternion-vector-angle! (new-stack-quaternion0) (new 'static 'vector :x 1.0 :w 1.0) arg2))) + (quaternion-normalize! (quaternion*! arg0 arg1 a2-1)) + ) + ) + +(defun quaternion-rotate-local-y! ((arg0 quaternion) (arg1 quaternion) (arg2 float)) + (let ((a2-1 (quaternion-vector-angle! (new-stack-quaternion0) (new 'static 'vector :y 1.0 :w 1.0) arg2))) + (quaternion-normalize! (quaternion*! arg0 arg1 a2-1)) + ) + ) + +(defun quaternion-rotate-local-z! ((arg0 quaternion) (arg1 quaternion) (arg2 float)) + (let ((a2-1 (quaternion-vector-angle! (new-stack-quaternion0) (new 'static 'vector :z 1.0 :w 1.0) arg2))) + (quaternion-normalize! (quaternion*! arg0 arg1 a2-1)) + ) + ) + +(defun quaternion-rotate-y! ((arg0 quaternion) (arg1 quaternion) (arg2 float)) + (let ((a1-2 (quaternion-vector-angle! (new-stack-quaternion0) (new 'static 'vector :y 1.0 :w 1.0) arg2))) + (quaternion-normalize! (quaternion*! arg0 a1-2 arg1)) + ) + ) + +(defun quaternion-rotate-x! ((arg0 quaternion) (arg1 quaternion) (arg2 float)) + (let ((a1-3 (quaternion-vector-angle! (new-stack-quaternion0) (vector-x-quaternion! (new-stack-vector0) arg1) arg2)) + ) + (quaternion-normalize! (quaternion*! arg0 a1-3 arg1)) + ) + ) + +(defun quaternion-rotate-z! ((arg0 quaternion) (arg1 quaternion) (arg2 float)) + (let ((a1-3 (quaternion-vector-angle! (new-stack-quaternion0) (vector-z-quaternion! (new-stack-vector0) arg1) arg2)) + ) + (quaternion-normalize! (quaternion*! arg0 a1-3 arg1)) + ) + ) + +(defun quaternion-delta-y ((arg0 quaternion) (arg1 quaternion)) + (acos (vector-dot + (vector-z-quaternion! (new 'stack-no-clear 'vector) arg0) + (vector-z-quaternion! (new 'stack-no-clear 'vector) arg1) + ) + ) + ) + +(defun quaternion-rotate-y-to-vector! ((arg0 quaternion) (arg1 quaternion) (arg2 quaternion) (arg3 float)) + (let ((s5-0 (new 'stack-no-clear 'quaternion))) + (let ((t9-0 vector-xz-normalize!) + (a0-1 (new 'stack-no-clear 'vector)) + ) + (set! (-> a0-1 x) (-> arg2 x)) + (set! (-> a0-1 y) 0.0) + (set! (-> a0-1 z) (-> arg2 z)) + (set! (-> a0-1 w) 1.0) + (let ((s0-0 (t9-0 a0-1 1.0))) + (quaternion-from-two-vectors-max-angle! + s5-0 + (vector-z-quaternion! (the-as vector (new 'stack-no-clear 'quaternion)) arg1) + s0-0 + arg3 + ) + ) + ) + (quaternion-normalize! (quaternion*! arg0 s5-0 arg1)) + ) + ) + +(defun vector-rotate-x! ((arg0 vector) (arg1 vector) (arg2 float)) + (let ((a1-2 (quaternion-vector-angle! (new 'stack-no-clear 'quaternion) (new 'static 'vector :x 1.0 :w 1.0) arg2)) + (s4-0 (new 'stack-no-clear 'matrix)) + ) + (quaternion->matrix s4-0 a1-2) + (vector-matrix*! arg0 arg1 s4-0) + ) + ) + +(defun vector-rotate-y! ((arg0 vector) (arg1 vector) (arg2 float)) + (let ((a1-2 (quaternion-vector-angle! (new 'stack-no-clear 'quaternion) (new 'static 'vector :y 1.0 :w 1.0) arg2)) + (s4-0 (new 'stack-no-clear 'matrix)) + ) + (quaternion->matrix s4-0 a1-2) + (vector-matrix*! arg0 arg1 s4-0) + ) + ) + +(defun vector-rotate-z! ((arg0 vector) (arg1 vector) (arg2 float)) + (let ((a1-2 (quaternion-vector-angle! (new 'stack-no-clear 'quaternion) (new 'static 'vector :z 1.0 :w 1.0) arg2)) + (s4-0 (new 'stack-no-clear 'matrix)) + ) + (quaternion->matrix s4-0 a1-2) + (vector-matrix*! arg0 arg1 s4-0) + ) + ) + +(defun vector-y-angle ((arg0 vector)) + (atan (-> arg0 x) (-> arg0 z)) + ) + +(defun vector-x-angle ((arg0 vector)) + (atan (-> arg0 y) (vector-xz-length arg0)) + ) + +(defun quaternion<-rotate-y-vector ((arg0 quaternion) (arg1 vector)) + (quaternion-vector-angle! arg0 (new 'static 'vector :y 1.0 :w 1.0) (vector-y-angle arg1)) + ) + +(defun-debug quaternion-validate ((arg0 quaternion)) + (with-pp + (let ((f0-0 (quaternion-norm arg0))) + (when (or (< 1.01 f0-0) (< f0-0 0.99)) + (format #t "WARNING: bad quaternion (magnitude ~F) process is " f0-0) + (if (and pp (type? pp process-tree)) + (format #t "~A~%" (-> pp name)) + (format #t "#f~%") + ) + ) + ) + (none) + ) + ) + +(defun quaternion-xz-angle ((arg0 quaternion)) + (let ((gp-0 (new 'stack-no-clear 'matrix)) + (s5-0 (new 'stack-no-clear 'vector)) + ) + (quaternion->matrix gp-0 arg0) + (set-vector! s5-0 0.0 0.0 1.0 1.0) + (vector-matrix*! s5-0 s5-0 gp-0) + (vector-y-angle s5-0) + ) + ) + + + + diff --git a/goal_src/jak2/engine/math/transform-h.gc b/goal_src/jak2/engine/math/transform-h.gc index bef9ef4a5d..e8db588dd1 100644 --- a/goal_src/jak2/engine/math/transform-h.gc +++ b/goal_src/jak2/engine/math/transform-h.gc @@ -20,6 +20,9 @@ (rot vector :inline :offset-assert 32) (scale vector :inline :offset-assert 48) ) + (:methods + (new (symbol type) _type_ 0) + ) :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 diff --git a/goal_src/jak2/engine/math/trigonometry-h.gc b/goal_src/jak2/engine/math/trigonometry-h.gc index 99adcb8c47..0be7ea6aeb 100644 --- a/goal_src/jak2/engine/math/trigonometry-h.gc +++ b/goal_src/jak2/engine/math/trigonometry-h.gc @@ -7,6 +7,15 @@ (define-extern deg-diff (function float float float)) (define-extern sin (function float float)) +(define-extern vector-sin-rad! (function vector vector vector)) +(define-extern vector-sincos-rad! (function vector vector vector int)) +(define-extern sincos-rad! (function (pointer float) float int)) +(define-extern sincos! (function (pointer float) float int)) +(define-extern vector-rad<-vector-deg/2! (function vector vector int)) (define-extern vector-sincos! (function vector vector vector int)) (define-extern cos (function float float)) +(define-extern atan-series-rad (function float float)) +(define-extern atan2-rad (function float float float)) (define-extern atan (function float float float)) +(define-extern acos (function float float)) +(define-extern acos-rad (function float float)) \ No newline at end of file diff --git a/goal_src/jak2/engine/math/trigonometry.gc b/goal_src/jak2/engine/math/trigonometry.gc index 420d9356f9..99544e0032 100644 --- a/goal_src/jak2/engine/math/trigonometry.gc +++ b/goal_src/jak2/engine/math/trigonometry.gc @@ -5,3 +5,1190 @@ ;; name in dgo: trigonometry ;; dgos: ENGINE, GAME +(defconstant ROT_TO_RAD (the-as float #x38c90fda)) +(defconstant PI (the-as float #x40490fda)) +(defconstant MINUS_PI (the-as float #xc0490fda)) +(defconstant PI_OVER_2 (the-as float #x3fc90fda)) +(defconstant TWO_PI (the-as float #x40c90fda)) + +;; There is a bug in some of the cosine functions that can be fixed by toggling this flag. +(defglobalconstant FIX_COSINE_BUG #f) + + +(defun radmod ((arg0 float)) + (let ((f0-1 (+ PI arg0))) + (if (< 0.0 f0-1) + (+ MINUS_PI (- f0-1 (* (the float (the int (/ f0-1 6.283185))) 6.283185))) + (+ PI (- f0-1 (* (the float (the int (/ f0-1 6.283185))) 6.283185))) + ) + ) + ) + +(defun deg- ((arg0 float) (arg1 float)) + (the float (sar (- (shl (the int arg0) 48) (shl (the int arg1) 48)) 48)) + ) + +(defun deg-diff ((arg0 float) (arg1 float)) + (the float (sar (- (shl (the int arg1) 48) (shl (the int arg0) 48)) 48)) + ) + +(defun deg-seek ((in float) (target float) (max-diff float)) + (let ((in-int (shl (the int in) 48)) + (target-int (shl (the int target) 48)) + ) + (let* ((max-diff-int (shl (the int max-diff) 48)) + (diff (- target-int in-int)) + (abs-diff (abs diff)) + ) + (set! target-int (cond + ((< abs-diff 0) + (+ in-int max-diff-int) + ) + ((>= max-diff-int abs-diff) + (empty) + target-int + ) + ((>= diff 0) + (+ in-int max-diff-int) + ) + (else + (- in-int max-diff-int) + ) + ) + ) + ) + (the float (sar target-int 48)) + ) + ) + +(defun deg-seek-smooth ((in float) (target float) (max-diff float) (amount float)) + (let ((step (* (deg- target in) amount))) + (if (< max-diff (fabs step)) + (set! step (if (>= step 0.0) + max-diff + (- max-diff) + ) + ) + ) + (+ in step) + ) + ) + +(defun deg-lerp-clamp ((min-val float) (max-val float) (in float)) + (cond + ((>= 0.0 in) + min-val + ) + ((>= in 1.0) + max-val + ) + (else + (the float (sar (shl (the int (+ min-val (* in (deg-diff min-val max-val)))) 48) 48)) + ) + ) + ) + +(define binary-table (the-as (array float) (new 'static 'boxed-array :type float + 1.0 + 0.5 + 0.25 + 0.125 + 0.0625 + 0.03125 + 0.015625 + 0.0078125 + 0.00390625 + 0.001953125 + 0.0009765625 + 0.00048828125 + 0.00024414062 + 0.00012207031 + 0.000061035156 + 0.000030517578 + 0.000015258789 + 0.0000076293945 + 0.0000038146973 + 0.0000019073486 + 0.0000009536743 + 0.00000047683716 + 0.00000023841858 + 0.00000011920929 + 0.000000059604645 + 0.000000029802322 + 0.000000014901161 + 0.000000007450581 + 0.0000000037252903 + 0.0000000018626451 + 0.0000000009313226 + 0.0000000004656613 + ) + ) + ) + +(define sincos-table (the-as (array float) (new 'static 'boxed-array :type float + 0.7853982 + 0.4636476 + 0.24497867 + 0.124354996 + 0.06241881 + 0.031239834 + 0.015623729 + 0.007812341 + 0.0039062302 + 0.0019531226 + 0.0009765622 + 0.0004882812 + 0.00024414062 + 0.00012207031 + 0.000061035156 + 0.000030517578 + 0.000015258789 + 0.0000076293945 + 0.0000038146973 + 0.0000019073486 + 0.0000009536743 + 0.00000047683716 + 0.00000023841858 + 0.00000011920929 + 0.000000059604645 + 0.000000029802322 + 0.000000014901161 + 0.000000007450581 + 0.0000000037252903 + 0.0000000018626451 + 0.0000000009313226 + 0.0000000004656613 + ) + ) + ) + +(defun sin ((arg0 float)) + (let ((f2-0 (* 0.000095873795 (the float (sar (shl (the int arg0) 48) 48))))) + f2-0 + (let* ((f1-4 (* 0.999998 f2-0)) + (f0-3 (* f2-0 f2-0)) + (f2-1 (* f2-0 f0-3)) + (f1-5 (+ f1-4 (* -0.16666014 f2-1))) + (f2-2 (* f2-1 f0-3)) + (f1-6 (+ f1-5 (* 0.008326521 f2-2))) + (f2-3 (* f2-2 f0-3)) + (f1-7 (+ f1-6 (* -0.0001956241 f2-3))) + (f0-4 (* f2-3 f0-3)) + ) + (+ f1-7 (* 0.0000023042373 f0-4)) + ) + ) + ) + +(defun sin-rad ((arg0 float)) + "Compute the sine of an angle in radians. + No unwrap is done, should be in -pi, pi" + (local-vars + (f1-0 float) + (f2-0 float) + (f3-0 float) + (f4-0 float) + (f5-0 float) + (f6-0 float) + (f7-0 float) + (f8-0 float) + (f9-0 float) + (f10-0 float) + (f11-0 float) + (acc float) + ) + (set! f1-0 (* arg0 arg0)) + (set! f7-0 0.999998) + (set! f8-0 -0.16666014) + (set! f2-0 (* arg0 f1-0)) + (set! f3-0 (* f1-0 f1-0)) + (set! f9-0 0.008326521) + (set! f4-0 (* f2-0 f1-0)) + (set! f5-0 (* f3-0 f2-0)) + (set! f10-0 -0.0001956241) + (set! f6-0 (* f4-0 f3-0)) + (set! f11-0 0.0000023042373) + ;;(.mula.s arg0 f7-0) + (set! acc (* arg0 f7-0)) + ;;(.madda.s f2-0 f8-0) + (set! acc (+ acc (* f2-0 f8-0))) + ;;(.madda.s f4-0 f9-0) + (set! acc (+ acc (* f4-0 f9-0))) + ;;(.madda.s f5-0 f10-0) + (set! acc (+ acc (* f5-0 f10-0))) + ;;(.madd.s f12-0 f6-0 f11-0) + (+ acc (* f6-0 f11-0)) + ) + +(define *sin-poly-vec* + (new 'static 'vector :x -0.16666014 :y 0.008326521 :z -0.0001956241 :w 0.0000023042373) + ) + +(define *sin-poly-vec2* (new 'static 'vector :x 0.999998)) + +(defun vector-sin-rad! ((arg0 vector) (arg1 vector)) + (rlet ((acc :class vf) + (vf1 :class vf) + (vf10 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + (vf8 :class vf) + (vf9 :class vf) + ) + (.lvf vf1 (&-> arg1 quad)) + (.mul.vf vf3 vf1 vf1) + (.lvf vf10 (&-> *sin-poly-vec2* quad)) + (.lvf vf9 (&-> *sin-poly-vec* quad)) + (.mul.vf vf4 vf3 vf1) + (.mul.vf vf5 vf3 vf3) + (.mul.x.vf acc vf1 vf10) + (.mul.vf vf6 vf4 vf3) + (.mul.vf vf7 vf5 vf4) + (.add.mul.x.vf acc vf4 vf9 acc) + (.mul.vf vf8 vf6 vf5) + (.add.mul.y.vf acc vf6 vf9 acc) + (.add.mul.z.vf acc vf7 vf9 acc) + (.add.mul.w.vf vf2 vf8 vf9 acc) + (.svf (&-> arg0 quad) vf2) + arg0 + ) + ) + +(defun cos-rad ((arg0 float)) + (local-vars (acc float)) + (let* ((f1-0 (* arg0 arg0)) + (f7-0 1.0) + (f8-0 -0.49998003) + (f3-0 (* f1-0 f1-0)) + (f9-0 0.041620404) + (f10-0 -0.0013636408) + (f4-0 (* f3-0 f1-0)) + (f5-0 (* f3-0 f3-0)) + (f11-0 0.000020170546) + ) + ;;(.mula.s f7-0 f7-0) + (set! acc (* f7-0 f7-0)) + ;;(.madda.s f8-0 f1-0) + (set! acc (+ acc (* f8-0 f1-0))) + ;;(.madda.s f9-0 f3-0) + (set! acc (+ acc (* f9-0 f3-0))) + ;;(.madda.s f10-0 f4-0) + (set! acc (+ acc (* f10-0 f4-0))) + ;;(.madd.s f12-0 f11-0 f5-0) + (+ acc (* f11-0 f5-0)) + ;;(the-as float f12-0) + ) + acc + ) + +(define *cos-poly-vec* (new 'static 'vector :x -0.49998003 :y 0.041620404 :z -0.0013636408 :w 0.000020170546)) + +(defun vector-cos-rad! ((arg0 vector) (arg1 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf9 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + ;; (.sub.vf vf2 vf2 vf2) + (.xor.vf vf2 vf2 vf2) + (.lvf vf9 (&-> *cos-poly-vec* quad)) + (.mul.vf vf3 vf1 vf1) + (.add.w.vf acc vf2 vf0) + (.mul.vf vf4 vf3 vf3) + (.add.mul.x.vf acc vf3 vf9 acc) + (.mul.vf vf5 vf4 vf3) + (.add.mul.y.vf acc vf4 vf9 acc) + (.mul.vf vf6 vf4 vf4) + (.add.mul.z.vf acc vf5 vf9 acc) + (.add.mul.w.vf vf2 vf6 vf9 acc) + (.svf (&-> arg0 quad) vf2) + arg0 + ) + ) + +(defun vector-sincos-rad! ((arg0 vector) (arg1 vector) (arg2 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf10 :class vf) + (vf11 :class vf) + (vf12 :class vf) + (vf13 :class vf) + (vf14 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + (vf8 :class vf) + (vf9 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg2 quad)) + ;; (.sub.vf vf14 vf14 vf14) + (.xor.vf vf14 vf14 vf14) + (.lvf vf11 (&-> *sin-poly-vec2* quad)) + (.mul.vf vf2 vf1 vf1) + (.lvf vf10 (&-> *sin-poly-vec* quad)) + (.lvf vf13 (&-> *cos-poly-vec* quad)) + (.mul.x.vf acc vf1 vf11) + (.mul.vf vf3 vf2 vf1) + (.mul.vf vf4 vf2 vf2) + (.mul.vf vf5 vf3 vf2) + (.mul.vf vf6 vf3 vf3) + (.mul.vf vf7 vf4 vf3) + (.mul.vf vf8 vf4 vf4) + (.mul.vf vf9 vf5 vf4) + (.add.mul.x.vf acc vf3 vf10 acc) + (.add.mul.y.vf acc vf5 vf10 acc) + (.add.mul.z.vf acc vf7 vf10 acc) + (.add.mul.w.vf vf12 vf9 vf10 acc) + (.add.w.vf acc vf14 vf0) + (.add.mul.x.vf acc vf2 vf13 acc) + (.add.mul.y.vf acc vf4 vf13 acc) + (.add.mul.z.vf acc vf6 vf13 acc) + (.add.mul.w.vf vf14 vf8 vf13 acc) + (.svf (&-> arg0 quad) vf12) + (.svf (&-> arg1 quad) vf14) + 0 + ) + ) + +(defmacro sincos-rad-asm (out x) + ;; Compute the sine and cosine of x, store it in the output array + ;; this assembly is shared in two functions. + `(rlet ((f10 :class fpr :type float) ;; coeff 1.0 + (f11 :class fpr :type float) ;; coeff -1/3! + (f12 :class fpr :type float) ;; coeff 1/5! + (f14 :class fpr :type float) ;; coeff -1/7! + (f15 :class fpr :type float) ;; coeff 1/9! + (f1 :class fpr :type float) ;; x + (f2 :class fpr :type float) ;; x^2 + (f3 :class fpr :type float) ;; x^3 + (f4 :class fpr :type float) ;; x^4 + (f5 :class fpr :type float) ;; x^5 + (f6 :class fpr :type float) ;; x^6 + (f7 :class fpr :type float) ;; x^7 + (f8 :class fpr :type float) ;; x^8 + (f9 :class fpr :type float) ;; x^9 + (f21 :class fpr :type float) + (f22 :class fpr :type float) ;; 0 ? + (acc :class fpr :type float) ;; temp + (f16 :class fpr :type float) ;; 1.0 + (f17 :class fpr :type float) ;; cos coeff 1 + (f18 :class fpr :type float) ;; cos coeff 2 + (f19 :class fpr :type float) ;; cos coeff 3 + (f20 :class fpr :type float) ;; cos coeff 4 + ) + ;; lui v1, 16255 + ;; lui a2, -16854 + ;; ori v1, v1, 65502 + ;; mtc1 f1, a1 + (set! f1 ,x) + ;; ori a1, a2, 43253 + ;; sub.s f22, f22, f22 + (set! f22 (the-as float 0)) + ;; lui a2, 15368 + ;; mtc1 f10, v1 + (set! f10 (the-as float #x3F7FFFDE)) ;; almost 1.0 + ;; ori v1, a2, 27638 + ;; mtc1 f11, a1 + (set! f11 (the-as float #xBE2AA8F5)) ;; -0.166, 1/3! + ;; lui a1, -18099 + ;; mul.s f2, f1, f1 + (set! f2 (* f1 f1)) + ;; ori a1, a1, 8306 + ;; mtc1 f12, v1 + (set! f12 (the-as float #x3C086BF6)) ;; 1/5! + ;; lui v1, 13850 + ;; mtc1 f14, a1 + (set! f14 (the-as float #xB94D2072)) ;; 1/7! + ;; ori a1, v1, 41599 + ;; mula.s f1, f10 + (set! acc (* f1 f10)) ;; x * c_1 + ;; lui v1, 16256 + ;; mul.s f3, f2, f1 + (set! f3 (* f2 f1)) ;; x^3 + ;; or v1, v1, r0 + ;; mul.s f4, f2, f2 + (set! f4 (* f2 f2)) ;; x^4 + ;; lui a2, -16641 + ;; mtc1 f15, a1 + (set! f15 (the-as float #x361AA27F)) ;; 1/9! + ;; lui a1, -16641 ;; I think this is a typo... + ;; or a1, a2, a1 ;; this should set the lower 16 bits. + ;; mtc1 f16, v1 + (set! f16 (the-as float #x3f800000)) ;; 1.0 + ;; sll r0, r0, 0 + ;; mtc1 f17, a1 + + ;; it looks like they set the lower 16-bits of the x^2 + ;; coefficient for cosine incorrectly + (#cond + (FIX_COSINE_BUG + ;; the constant used in *cos-poly-vec* + (set! f17 (the-as float #xbefffd62)) + ) + (#t + ;; missing the lower 16 bits. + (set! f17 (the-as float #xBEFF0000)) + ) + ) + + ;; sll r0, r0, 0 + ;; mul.s f5, f3, f2 + (set! f5 (* f3 f2)) + ;; sll r0, r0, 0 + ;; mul.s f6, f3, f3 + (set! f6 (* f3 f3)) + ;; sll r0, r0, 0 + ;; mul.s f7, f4, f3 + (set! f7 (* f4 f3)) + ;; sll r0, r0, 0 + ;; mul.s f8, f4, f4 + (set! f8 (* f4 f4)) + ;; sll r0, r0, 0 + ;; mul.s f9, f5, f4 + (set! f9 (* f5 f4)) + ;; lui v1, 15658 + ;; madda.s f3, f11 + (set! acc (+ acc (* f3 f11))) ;; add x^3 sine term + ;; ori v1, v1, 31272 + ;; madda.s f5, f12 + (set! acc (+ acc (* f5 f12))) ;; add x^5 sine term + ;; lui a1, -17742 + ;; madda.s f7, f14 + (set! acc (+ acc (* f7 f14))) ;; add x^7 sine term + ;; ori a1, a1, 48177 + ;; madd.s f21, f9, f15 + (set! f21 (+ acc (* f9 f15))) ;; add x^9 sine term + ;; lui a2, 14249 + ;; mtc1 f18, v1 + (set! f18 (the-as float #x3D2A7A28)) ;; cos coeff + ;; ori v1, a2, 13291 + ;; mtc1 f19, a1 + (set! f19 (the-as float #xBAB2BC31)) ;; cos coeff + ;; sll r0, r0, 0 + ;; mtc1 f20, v1 + (set! f20 (the-as float #x37A933EB)) + ;; sll r0, r0, 0 + ;; mula.s f16, f16 + (set! acc (* f16 f16)) ;; acc = 1, constant cos term. + ;; sll r0, r0, 0 + ;; madda.s f2, f17 + (set! acc (+ acc (* f2 f17))) + ;; sll r0, r0, 0 + ;; madda.s f4, f18 + (set! acc (+ acc (* f4 f18))) + ;; sll r0, r0, 0 + ;; madda.s f6, f19 + (set! acc (+ acc (* f6 f19))) + ;; sll r0, r0, 0 + ;; madd.s f22, f8, f20 + (set! f22 (+ acc (* f8 f20))) + ;; sll r0, r0, 0 + ;; swc1 f21, 0(a0) + (set! (-> ,out 0) f21) + ;; sll r0, r0, 0 + ;; swc1 f22, 4(a0) + (set! (-> ,out 1) f22) + ;; or v0, r0, r0 + 0 + ) + ) + +(defun sincos-rad! ((out (pointer float)) (x float)) + "Compute the sine and cosine of x, store it in the output array. + Has the cosine bug." + (sincos-rad-asm out x) + ) + +(defun sincos! ((out (pointer float)) (x float)) + "Compute the sine and cosine of x, store it in the output array. + The input is in rotation units, and is unwrapped properly. + Also has the cosine bug" + (sincos-rad-asm out (* ROT_TO_RAD (the float (sar (shl (the int x) 48) 48)))) + ) + +(defun vector-rad<-vector-deg! ((arg0 vector) (arg1 vector)) + (local-vars (v0-0 float) (v1-1 uint128) (v1-2 uint128) (v1-3 uint128)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + ) + (let ((v1-0 #x38c90fda)) + (.lvf vf1 (&-> arg1 quad)) + (.ftoi.vf vf1 vf1) + (.mov vf2 v1-0) + ) + (.mov v1-1 vf1) + (.pw.sll v1-2 v1-1 16) + (.pw.sra v1-3 v1-2 16) + (.mov vf1 v1-3) + (.itof.vf vf1 vf1) + (.mul.x.vf vf1 vf1 vf2) + (.svf (&-> arg0 quad) vf1) + (.mov v0-0 vf1) + (none) + ) + ) + +(defun vector-rad<-vector-deg/2! ((arg0 vector) (arg1 vector)) + (local-vars (v0-0 float) (v1-1 uint128) (v1-2 uint128) (v1-3 uint128)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + ) + (let ((v1-0 #x38c90fda)) + (let ((a2-0 #x3f000000)) + (.lvf vf1 (&-> arg1 quad)) + (.mov vf2 a2-0) + ) + (.mul.x.vf vf1 vf1 vf2) + (.ftoi.vf vf1 vf1) + (.mov vf2 v1-0) + ) + (.mov v1-1 vf1) + (.pw.sll v1-2 v1-1 16) + (.pw.sra v1-3 v1-2 16) + (.mov vf1 v1-3) + (.itof.vf vf1 vf1) + (.mul.x.vf vf1 vf1 vf2) + (.svf (&-> arg0 quad) vf1) + (.mov v0-0 vf1) + (the-as int v0-0) + ) + ) + +(defun vector-sincos! ((arg0 vector) (arg1 vector) (arg2 vector)) + (let ((s4-0 (new 'stack-no-clear 'vector))) + (vector-rad<-vector-deg! s4-0 arg2) + (vector-sincos-rad! arg0 arg1 s4-0) + ) + ) + +(defun tan-rad ((arg0 float)) + (/ (sin arg0) (cos arg0)) + ) + +(defun cos ((arg0 float)) + (sin (+ 16384.0 arg0)) + ) + +(defun tan ((arg0 float)) + (/ (sin arg0) (cos arg0)) + ) + +(defun atan0 ((arg0 float) (arg1 float)) + "inverse tangent, to rotation units. y,x order. Does not handle signs correctly. + Do not use this function directly, instead use atan2" + (rlet ((f20 :class fpr :type float) + (f21 :class fpr :type float) + (f1 :class fpr :type float) + (f2 :class fpr :type float) + (f3 :class fpr :type float) + (f4 :class fpr :type float) + (f5 :class fpr :type float) + (f6 :class fpr :type float) + (f7 :class fpr :type float) + (f8 :class fpr :type float) + (f9 :class fpr :type float) + (f10 :class fpr :type float) + (f19 :class fpr :type float) + (f11 :class fpr :type float) + (f12 :class fpr :type float) + (f13 :class fpr :type float) + (f14 :class fpr :type float) + (f15 :class fpr :type float) + (f16 :class fpr :type float) + (f17 :class fpr :type float) + (f18 :class fpr :type float) + (acc :class fpr :type float) + ) + + ;;mtc1 f20, a1 + (set! f20 arg1) + ;;mtc1 f21, a0 + (set! f21 arg0) + ;;sub.s f1, f21, f20 + (set! f1 (- f21 f20)) + ;;add.s f2, f21, f20 + (set! f2 (+ f21 f20)) + ;;div.s f1, f1, f2 + (set! f1 (/ f1 f2)) + ;;lwc1 f19, L132(fp) + (set! f19 (the-as float #x46000000)) + ;;lwc1 f11, L140(fp) + (set! f11 (the-as float #x4622f97c)) + ;;lwc1 f12, L151(fp) + (set! f12 (the-as float #xc55946e1)) + ;;lwc1 f13, L120(fp) + (set! f13 (the-as float #x450207fd)) + ;;lwc1 f14, L126(fp) + (set! f14 (the-as float #xc4b556ce)) + ;;lwc1 f15, L113(fp) + (set! f15 (the-as float #x447b6ca4)) + ;;mul.s f2, f1, f1 + (set! f2 (* f1 f1)) + ;;lwc1 f16, L142(fp) + (set! f16 (the-as float #xc411ca52)) + ;;lwc1 f17, L118(fp) + (set! f17 (the-as float #x43640558)) + ;;mul.s f3, f1, f2 + (set! f3 (* f1 f2)) + ;;mul.s f1, f1, f11 + (set! f1 (* f1 f11)) + ;;mul.s f4, f2, f2 + (set! f4 (* f2 f2)) + ;;lwc1 f18, L141(fp) + (set! f18 (the-as float #xc2292434)) + ;;mul.s f5, f3, f2 + (set! f5 (* f3 f2)) + ;;mul.s f6, f4, f3 + (set! f6 (* f4 f3)) + ;;mul.s f7, f5, f4 + (set! f7 (* f5 f4)) + ;;mul.s f8, f6, f4 + (set! f8 (* f6 f4)) + ;;mul.s f9, f7, f4 + (set! f9 (* f7 f4)) + ;;mul.s f10, f8, f4 + (set! f10 (* f8 f4)) + ;;adda.s f1, f19 + (set! acc (+ f1 f19)) + ;;madda.s f3, f12 + (set! acc (+ acc (* f3 f12))) + + ;;madda.s f5, f13 + (set! acc (+ acc (* f5 f13))) + + ;;madda.s f6, f14 + (set! acc (+ acc (* f6 f14))) + + ;;madda.s f7, f15 + (set! acc (+ acc (* f7 f15))) + + ;;madda.s f8, f16 + (set! acc (+ acc (* f8 f16))) + + ;;madda.s f9, f17 + (set! acc (+ acc (* f9 f17))) + + ;;madd.s f19, f10, f18 + ;;mfc1 v0, f19 + (+ acc (* f10 f18)) + ) + ) + +(defmacro .adda.s (a b) + `(set! acc (+ ,a ,b)) + ) + +(defmacro .madda.s (a b) + `(set! acc (+ acc (* ,a ,b))) + ) + +(defmacro .madd.s (a b c) + `(set! ,a (+ acc (* ,b ,c))) + ) + +(defun atan-series-rad ((arg0 float)) + "A helper function for atan" + (local-vars + (f0-1 float) + (f1-0 float) + (f2-0 float) + (f3-0 float) + (f4-0 float) + (f5-0 float) + (f6-0 float) + (f7-0 float) + (f8-0 float) + (f9-0 float) + (f10-0 float) + (f11-0 float) + (f12-0 float) + (f13-0 float) + (f14-0 float) + (f15-0 float) + (f16-0 float) + (f17-0 float) + (f18-0 float) + (acc float) + (f18-1 float) + ) + (set! f1-0 (* arg0 arg0)) + (set! f10-0 (the-as float #x3f7ffff5)) + (set! f11-0 (the-as float #xbeaaa61c)) + (set! f2-0 (* arg0 f1-0)) + (set! f3-0 (* f1-0 f1-0)) + (set! f12-0 (the-as float #x3e4c40a6)) + (set! f4-0 (* f2-0 f1-0)) + (set! f5-0 (* f3-0 f2-0)) + (set! f13-0 (the-as float #xbe0e6c63)) + (set! f6-0 (* f4-0 f3-0)) + (set! f7-0 (* f5-0 f3-0)) + (set! f14-0 (the-as float #x3dc577df)) + (set! f8-0 (* f6-0 f3-0)) + (set! f9-0 (* f7-0 f3-0)) + (set! f15-0 (the-as float #xbd6501c4)) + (set! f18-0 (the-as float #x3f490fdb)) + (set! f0-1 (* arg0 f10-0)) + (set! f16-0 (the-as float #x3cb31652)) + (set! f17-0 (the-as float #xbb84d7e7)) + (.adda.s f0-1 f18-0) + (.madda.s f2-0 f11-0) + (.madda.s f4-0 f12-0) + (.madda.s f5-0 f13-0) + (.madda.s f6-0 f14-0) + (.madda.s f7-0 f15-0) + (.madda.s f8-0 f16-0) + (.madd.s f18-1 f9-0 f17-0) + ;;(the-as float f18-1) + f18-1 + ) + + +(defun atan-rad ((arg0 float)) + (atan-series-rad (/ (+ -1.0 arg0) (+ 1.0 arg0))) + ) + +(defun sign ((arg0 float)) + (cond + ((< 0.0 arg0) + 1.0 + ) + ((< arg0 0.0) + -1.0 + ) + (else + 0.0 + ) + ) + ) + +(defun atan2-rad ((arg0 float) (arg1 float)) + (cond + ((= arg1 0.0) + (* 1.5707963 (sign arg0)) + ) + ((and (< arg0 0.0) (< arg1 0.0)) + (let ((f30-1 MINUS_PI) + (f0-6 (/ arg0 arg1)) + ) + (+ f30-1 (atan-series-rad (/ (+ -1.0 f0-6) (+ 1.0 f0-6)))) + ) + ) + ((< arg0 0.0) + (let ((f0-14 (- (/ arg0 arg1)))) + (- (atan-series-rad (/ (+ -1.0 f0-14) (+ 1.0 f0-14)))) + ) + ) + ((< arg1 0.0) + (let ((f30-2 PI) + (f0-22 (- (/ arg0 arg1))) + ) + (- f30-2 (atan-series-rad (/ (+ -1.0 f0-22) (+ 1.0 f0-22)))) + ) + ) + (else + (let ((f0-28 (/ arg0 arg1))) + (atan-series-rad (/ (+ -1.0 f0-28) (+ 1.0 f0-28))) + ) + ) + ) + ) + +(deftype float-type (uint32) + () + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(define exp-slead (new 'static 'array float 32 + 1.0 + 1.0218964 + 1.0442734 + 1.0671387 + 1.0905075 + 1.1143799 + 1.1387863 + 1.1637192 + 1.1892014 + 1.2152405 + 1.2418518 + 1.2690506 + 1.2968369 + 1.3252335 + 1.354248 + 1.3839035 + 1.4142075 + 1.4451752 + 1.4768219 + 1.5091629 + 1.5422058 + 1.5759735 + 1.6104889 + 1.645752 + 1.6817856 + 1.7186127 + 1.7562485 + 1.7947083 + 1.8340073 + 1.8741608 + 1.9151993 + 1.9571381 + ) + ) + +(define exp-strail (new 'static 'array float 32 + 0.0 + 0.0000007863494 + 0.00000040596257 + 0.0000017288019 + 0.00000022534104 + 0.0000068597833 + 0.0000023188388 + 0.0000056815315 + 0.0000057600223 + 0.0000068814647 + 0.000006005433 + 0.0000003590472 + 0.0000027016238 + 0.000003183687 + 0.000007500062 + 0.000006378546 + 0.000006103877 + 0.0000056360786 + 0.0000042465254 + 0.0000015247614 + 0.000005014861 + 0.000007334366 + 0.0000014403477 + 0.000003525029 + 0.000007247011 + 0.000006627224 + 0.0000036862523 + 0.00000082304996 + 0.0000008232258 + 0.0000068675085 + 0.000007281612 + 0.000006062652 + ) + ) + +(defun exp ((arg float)) + (local-vars + (f0 float) + (f1 float) + (f2 float) + (f3 float) + (f4 float) + (f5 float) + (f6 float) + (f7 float) + (f8 float) + (f10 float) + (f11 float) + (f12 float) + (f13 float) + (f14 float) + (f15 float) + (f16 float) + (f17 float) + (f18 float) + (a2 int) + (v0 float) + (v1 int) + (a1 int) + (a3 int) + (t0 int) + (a0-2 int) + ) + + (set! f0 arg) + (set! f0 (fabs f0)) + (set! f1 (the-as float #x435c6bba)) + ;;(b! (>=.s f1 f0) L44 (nop!)) + (when-goto (>= f1 f0) L44) + + (set! f0 0.0) + (set! f1 arg) + ;;(b! (>=.s f0 f1) L42 (nop!)) + (when-goto (>= f0 f1) L42) + + (set! v0 (the-as float #x7f7fffff)) + ;;(b! #t L43 (nop!)) + (goto L43) + + (label L42) + (set! v0 (the-as float #x0)) + + (label L43) + ;;(b! #t L49 (nop!)) + (goto L49) + + + (label L44) + (set! f1 (the-as float #x33000000)) + ;;(b! (>=.s f0 f1) L45 (nop!)) + (when-goto (>= f0 f1) L45) + + (set! f0 (the-as float #x3f800000)) + (set! f1 arg) + (set! f0 (+ f0 f1)) + (set! v0 f0) + ;;(b! #t L49 (nop!)) + (goto L49) + + (label L45) + (set! f16 (the-as float #x4238aa3b)) + (set! f12 (the-as float #x3cb17200)) + (set! f13 (the-as float #x333fbe8e)) + (set! f14 (the-as float #x3f000044)) + (set! f15 (the-as float #x3e2aaaec)) + (set! f0 arg) + (set! f0 (* f0 f16)) + ;;(set! f0 (f2i f0)) + ;;(set! a2 (fpr->gpr f0)) + (set! a2 (the int f0)) + (set! v1 (logand a2 31)) + (set! a1 (- a2 v1)) + (set! a3 512) + (set! t0 a2) + ;;(bl! (<0.si t0) L46 (no-delay!)) + ;;(set! t0 (- t0)) + (set! t0 (abs t0)) + + ;;(label L46) + ;;(b! (>=.si a3 t0) L47 (nop!)) + (when-goto (>= a3 t0) L47) + ;;(set! f17 a1) + ;;(set! f18 v1) + ;;(set! f17 (i2f f17)) + ;;(set! f18 (i2f f18)) + (set! f17 (the float a1)) + (set! f18 (the float v1)) + (set! f17 (* f17 f12)) + (set! f18 (* f18 f12)) + (set! f0 arg) + (set! f17 (- f0 f17)) + ;;(b! #t L48 (set! f2 (-.s f17 f18))) + (set! f2 (- f17 f18)) + (goto L48) + + (label L47) + ;;(set! f17 (gpr->fpr a2)) + ;;(set! f17 (i2f f17)) + (set! f17 (the float a2)) + (set! f17 (* f17 f12)) + (set! f0 arg) + (set! f2 (- f0 f17)) + + (label L48) + (set! a0-2 (- a2)) + ;;(set! f17 (gpr->fpr a0)) + ;;(set! f17 (i2f f17)) + (set! f17 (the float a0-2)) + (set! f3 (* f17 f13)) + (set! a0-2 (sar a1 5)) + (set! f4 (+ f2 f3)) + (set! f6 (* f4 f15)) + (set! f6 (+ f14 f6)) + (set! f6 (* f4 f6)) + (set! f6 (* f4 f6)) + (set! f5 (+ f3 f6)) + (set! f5 (+ f2 f5)) + ;;(set! a1 exp-slead) + ;;(set! a2 (sll v1 2)) + ;;(set! a1 (+ a1 a2)) + ;;(set! f10 (l.f a1)) + (set! f10 (-> exp-slead v1)) + ;;(set! a1 exp-strail) + ;;(set! v1 (sll v1 2)) + ;;(set! v1 (+ a1 v1)) + ;;(set! f11 (l.f v1)) + (set! f11 (-> exp-strail v1)) + (set! f7 (+ f10 f11)) + (set! f8 (* f7 f5)) + (set! f8 (+ f11 f8)) + (set! f8 (+ f8 f10)) + (set! v1 (the-as int f8)) + (set! a0-2 (logand a0-2 511)) + (set! a0-2 (shl a0-2 23)) + (set! v0 (the-as float (+ v1 a0-2))) + (label L49) + v0 + ) + +(defun atan ((arg0 float) (arg1 float)) + (cond + ((and (= arg1 0.0) (= arg0 0.0)) + 0.0 + ) + ((and (< arg1 0.0) (< arg0 0.0)) + (+ -32768.0 (atan0 (- arg0) (- arg1))) + ) + ((< arg0 0.0) + (- (atan0 (- arg0) arg1)) + ) + ((< arg1 0.0) + (- 32768.0 (atan0 arg0 (- arg1))) + ) + (else + (atan0 arg0 arg1) + ) + ) + ) + +(defun asin ((arg0 float)) + (let ((gp-0 #f)) + 0.0 + (when (< arg0 0.0) + (set! arg0 (- arg0)) + (set! gp-0 #t) + ) + (let ((f0-5 (cond + ((< 1.0 arg0) + 16383.996 + ) + (else + (let* ((f0-6 1.0) + (f1-2 arg0) + (f0-8 (sqrtf (- f0-6 (* f1-2 f1-2))))) + (atan0 arg0 f0-8)) + ) + ) + ) + ) + (if gp-0 + (- f0-5) + f0-5 + ) + ) + ) + ) + +(defun acos ((arg0 float)) + "Inverse cosine. Returns rotation units" + (let ((result (- 16384.000000 (asin arg0)))) + (#when PC_PORT + ;; to avoid punch glitch: + ;; (note: it might be a better fix to change the global rounding mode, + ;; but it's not super clear to me that the mode picked by PCSX2 is + ;; more accurate than normal in all cases. So, we'll do this for now.) + (when (= result 0.0) + (set! result 0.00000000001) + ) + ) + result + ) + ) + +(defun acos-rad ((arg0 float)) + (cond + ((>= arg0 0.0) + (let* ((f0-1 1.0) + (f1-1 arg0) + (f0-3 (sqrtf (- f0-1 (* f1-1 f1-1)))) + (f0-5 (/ (- f0-3 arg0) (+ f0-3 arg0))) + ) + (atan-series-rad f0-5) + ) + ) + (else + (let* ((f0-6 1.0) + (f1-6 arg0) + (f0-8 (sqrtf (- f0-6 (* f1-6 f1-6)))) + (f0-10 (/ (+ f0-8 arg0) (- f0-8 arg0))) + ) + (- PI (atan-series-rad f0-10)) + ) + ) + ) + ) + +(defun sinerp ((arg0 float) (arg1 float) (arg2 float)) + (lerp arg0 arg1 (sin (* 16384.0 arg2))) + ) + +(defun sinerp-clamp ((minimum float) (maximum float) (amount float)) + (cond + ((>= 0.0 amount) + minimum + ) + ((>= amount 1.0) + maximum + ) + (else + (sinerp minimum maximum amount) + ) + ) + ) + +(defun coserp ((minimum float) (maximum float) (amount float)) + (lerp minimum maximum (- 1.0 (cos (* 16384.0 amount)))) + ) + +(defun coserp-clamp ((minimum float) (maximum float) (amount float)) + (cond + ((>= 0.0 amount) + minimum + ) + ((>= amount 1.0) + maximum + ) + (else + (coserp minimum maximum amount) + ) + ) + ) + +(defun coserp180 ((minimum float) (maximum float) (amount float)) + (lerp minimum maximum (* 0.5 (- 1.0 (cos (* 32768.0 amount))))) + ) + +(defun coserp180-clamp ((minimum float) (maximum float) (amount float)) + (cond + ((>= 0.0 amount) + minimum + ) + ((>= amount 1.0) + maximum + ) + (else + (coserp180 minimum maximum amount) + ) + ) + ) + +(defun ease-in-out ((total int) (progress int)) + (local-vars (v1-0 int)) + (cond + ((>= progress total) + 1.0 + ) + ((<= progress 0) + 0.0 + ) + ((begin (set! v1-0 (/ total 2)) (< v1-0 progress)) + (let ((a0-1 (- progress total))) + (+ 0.5 (* 0.5 (sin (- 16384.0 (/ (* 16384.0 (the float a0-1)) (the float v1-0)))))) + ) + ) + (else + (- 0.5 (* 0.5 (cos (/ (* 16384.0 (the float progress)) (the float v1-0))))) + ) + ) + ) diff --git a/goal_src/jak2/engine/math/vector-h.gc b/goal_src/jak2/engine/math/vector-h.gc index b52344f9f3..e06c190ff6 100644 --- a/goal_src/jak2/engine/math/vector-h.gc +++ b/goal_src/jak2/engine/math/vector-h.gc @@ -7,11 +7,18 @@ (define-extern vector-cross! (function vector vector vector vector)) (define-extern vector-float*! (function vector vector float vector)) +(define-extern vector+float*! (function vector vector vector float vector)) +(define-extern vector-negate! (function vector vector vector)) (define-extern vector-identity! (function vector vector)) (define-extern vector-length (function vector float)) (define-extern vector-length-squared (function vector float)) +(define-extern vector-xz-length (function vector float)) +(define-extern vector-vector-distance (function vector vector float)) +(define-extern vector-vector-distance-squared (function vector vector float)) (define-extern vector-normalize! (function vector float vector)) (define-extern vector-normalize-copy! (function vector vector float vector)) +(define-extern vector-normalize-ret-len! (function vector float float)) +(define-extern vector-xz-normalize! (function vector float vector)) (defmacro init-vf0-vector () @@ -218,6 +225,7 @@ (x float :offset 0) (y float :offset 4) ) + :allow-misaligned :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 diff --git a/goal_src/jak2/engine/math/vector.gc b/goal_src/jak2/engine/math/vector.gc index 02d3e5fac2..89ccce9fd4 100644 --- a/goal_src/jak2/engine/math/vector.gc +++ b/goal_src/jak2/engine/math/vector.gc @@ -5,3 +5,1666 @@ ;; name in dgo: vector ;; dgos: ENGINE, GAME +(defun vector-cross! ((arg0 vector) (arg1 vector) (arg2 vector)) + "Compute the cross product. The w component is set to junk." + (rlet ((acc :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.outer.product.a.vf acc vf1 vf2) + (.outer.product.b.vf vf3 vf2 vf1 acc) + (.svf (&-> arg0 quad) vf3) + arg0 + ) + ) + +(defun vector-xz-cross! ((arg0 vector) (arg1 vector) (arg2 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.add.x.vf vf1 vf0 vf0 :mask #b10) + (.add.x.vf vf2 vf0 vf0 :mask #b10) + (.outer.product.a.vf acc vf1 vf2) + (.outer.product.b.vf vf3 vf2 vf1 acc) + (.svf (&-> arg0 quad) vf3) + arg0 + ) + ) + +(defun vector+float! ((arg0 vector) (arg1 vector) (arg2 float)) + (rlet ((vf0 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (init-vf0-vector) + (.mov vf6 arg2) + (.lvf vf4 (&-> arg1 quad)) + (.add.x.vf vf5 vf0 vf0 :mask #b1000) + (.add.x.vf vf5 vf4 vf6 :mask #b111) + (.svf (&-> arg0 quad) vf5) + arg0 + ) + ) + +(defun vector*! ((arg0 vector) (arg1 vector) (arg2 vector)) + (rlet ((vf0 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (init-vf0-vector) + (.lvf vf4 (&-> arg1 quad)) + (.lvf vf5 (&-> arg2 quad)) + (.add.x.vf vf6 vf0 vf0 :mask #b1000) + (.mul.vf vf6 vf4 vf5 :mask #b111) + (.svf (&-> arg0 quad) vf6) + arg0 + ) + ) + +(defun vector+*! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (init-vf0-vector) + (.mov vf7 arg3) + (.lvf vf5 (&-> arg2 quad)) + (.lvf vf4 (&-> arg1 quad)) + (.add.x.vf vf6 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf5 vf7 :mask #b111) + (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111) + (.svf (&-> arg0 quad) vf6) + arg0 + ) + ) + +(defun vector-*! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (init-vf0-vector) + (.mov vf7 arg3) + (.lvf vf5 (&-> arg2 quad)) + (.lvf vf4 (&-> arg1 quad)) + (.add.x.vf vf6 vf0 vf0 :mask #b1000) + (.mul.w.vf acc vf4 vf0 :mask #b111) + (.sub.mul.x.vf vf6 vf5 vf7 acc :mask #b111) + (.svf (&-> arg0 quad) vf6) + arg0 + ) + ) + +(defun vector/! ((arg0 vector) (arg1 vector) (arg2 vector)) + (rlet ((Q :class vf) + (vf0 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (init-vf0-vector) + (.lvf vf5 (&-> arg2 quad)) + (.div.vf Q vf0 vf5 :fsf #b11 :ftf #b1) + (.add.x.vf vf6 vf0 vf0 :mask #b1000) + (.lvf vf4 (&-> arg1 quad)) + (let ((v1-0 (/ (-> arg1 x) (-> arg2 x)))) + (.wait.vf) + (.mul.vf vf6 vf4 Q :mask #b10) + (.nop.vf) + (.nop.vf) + (.div.vf Q vf0 vf5 :fsf #b11 :ftf #b10) + (.mov vf7 v1-0) + ) + (.add.x.vf vf6 vf0 vf7 :mask #b1) + (.wait.vf) + (.mul.vf vf6 vf4 Q :mask #b100) + (.nop.vf) + (.nop.vf) + (.svf (&-> arg0 quad) vf6) + arg0 + ) + ) + +(defun vector-float*! ((arg0 vector) (arg1 vector) (arg2 float)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (.mov vf2 arg2) + (.add.x.vf vf1 vf0 vf0 :mask #b1000) + (.mul.x.vf vf1 vf1 vf2 :mask #b111) + (.svf (&-> arg0 quad) vf1) + arg0 + ) + ) + +(defun vector-average! ((arg0 vector) (arg1 vector) (arg2 vector)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 #x3f000000)) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.mov vf3 v1-0) + ) + (.add.x.vf vf4 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf1 vf3) + (.add.mul.x.vf vf4 vf2 vf3 acc :mask #b111) + (.svf (&-> arg0 quad) vf4) + arg0 + ) + ) + +(defun vector+float*! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (.lvf vf2 (&-> arg2 quad)) + (.lvf vf1 (&-> arg1 quad)) + (.mov vf3 arg3) + (.add.x.vf vf4 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf2 vf3) + (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111) + (.svf (&-> arg0 quad) vf4) + arg0 + ) + ) + +(defun vector--float*! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (.lvf vf2 (&-> arg2 quad)) + (.lvf vf1 (&-> arg1 quad)) + (.mov vf3 arg3) + (.add.x.vf vf4 vf0 vf0 :mask #b1000) + (.mul.w.vf acc vf1 vf0) + (.sub.mul.x.vf vf4 vf2 vf3 acc :mask #b111) + (.svf (&-> arg0 quad) vf4) + arg0 + ) + ) + +(defun vector-float/! ((arg0 vector) (arg1 vector) (arg2 float)) + (rlet ((Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (.mov vf3 arg2) + (.div.vf Q vf0 vf3 :fsf #b11 :ftf #b0) + (.lvf vf1 (&-> arg1 quad)) + (.add.x.vf vf4 vf0 vf0 :mask #b1000) + (.wait.vf) + (.mul.vf vf4 vf1 Q :mask #b111) + (.nop.vf) + (.nop.vf) + (.svf (&-> arg0 quad) vf4) + arg0 + ) + ) + +(defun vector-negate! ((arg0 vector) (arg1 vector)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (.sub.vf vf4 vf0 vf1 :mask #b111) + (.add.x.vf vf4 vf0 vf0 :mask #b1000) + (.svf (&-> arg0 quad) vf4) + arg0 + ) + ) + +(defun vector-negate-in-place! ((arg0 vector)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 quad)) + (.sub.vf vf1 vf0 vf1 :mask #b111) + (.svf (&-> arg0 quad) vf1) + arg0 + ) + ) + +(defun vector= ((arg0 vector) (arg1 vector)) + "Are the two vectors equal? Does not compare the w component. + The implementation is cool." + + ;; (label L91) + ;; (set! v0-0 #t) + ;; (set! v1-0 #xffff) + (let* ((v1-0 #xffff) + ;; (set! a0-1 (l.q a0-0)) + (a0-1 (-> arg0 quad)) + ;; (set! v1-1 (sll v1-0 48)) + (v1-1 (shl v1-0 48)) + ;; (set! a1-1 (l.q a1-0)) + (a1-1 (-> arg1 quad)) + (a0-2 (the uint128 0)) + (r0 (the uint128 0)) + ) + ;; (.pceqw a0-2 a0-1 a1-1) + (.pceqw a0-2 a0-1 a1-1) + ;; (.ppach a0-3 r0-0 a0-2) + (.ppach a0-2 r0 a0-2) + ;; (set! v1-2 (logior a0-3 v1-1)) + (set! v1-1 (logior (the int a0-2) v1-1)) + ;; (set! v1-3 (+ v1-2 1)) + ;; will overflow the 64-bit integer if xyz is equal. + (set! v1-1 (+ v1-1 1)) + (zero? v1-1) + ) + + ;; (b! (zero? v1-3) L92 (nop!)) + ;; (set! v0-0 #f) + ;; (label L92) + ;; (ret-value v0-0) + + ) + +(defun vector-delta ((arg0 vector) (arg1 vector)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 quad)) + (.lvf vf2 (&-> arg1 quad)) + (.sub.vf vf1 vf2 vf1) + (.abs.vf vf1 vf1) + (.mul.x.vf acc vf0 vf1 :mask #b1000) + (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000) + (.add.mul.z.vf vf3 vf0 vf1 acc :mask #b1000) + (.add.w.vf vf3 vf0 vf3 :mask #b1) + (.mov v0-0 vf3) + v0-0 + ) + ) + +(defun vector-seek! ((arg0 vector) (arg1 vector) (arg2 float)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + ) + (init-vf0-vector) + (.mov vf4 arg2) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg0 quad)) + (.add.x.vf vf1 vf0 vf0 :mask #b1000) + (.sub.x.vf vf5 vf0 vf4 :mask #b1) + (.sub.vf vf3 vf1 vf2 :mask #b111) + (.min.x.vf vf3 vf3 vf4 :mask #b111) + (.max.x.vf vf3 vf3 vf5 :mask #b111) + (.add.vf vf1 vf2 vf3 :mask #b111) + (.svf (&-> arg0 quad) vf1) + arg0 + ) + ) + +(defun vector-smooth-seek! ((arg0 vector) (arg1 vector) (arg2 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 (new 'stack-no-clear 'vector))) + (vector-! v1-0 arg1 arg0) + (let ((v0-0 arg0)) + (let ((a1-2 (fmin 1.0 arg2))) + (.mov vf7 a1-2) + ) + (.lvf vf5 (&-> v1-0 quad)) + (.lvf vf4 (&-> arg0 quad)) + (.add.x.vf vf6 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf5 vf7 :mask #b111) + (.add.mul.w.vf vf6 vf4 vf0 acc :mask #b111) + (.svf (&-> v0-0 quad) vf6) + v0-0 + ) + ) + ) + ) + +(defun vector-seek-2d-xz-smooth! ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float)) + (let ((f0-1 (- (-> arg1 x) (-> arg0 x))) + (f2-1 (- (-> arg1 z) (-> arg0 z))) + ) + (when (or (!= f0-1 0.0) (!= f2-1 0.0)) + (let* ((f1-5 (* f0-1 arg3)) + (f0-3 (* f2-1 arg3)) + (f2-4 (sqrtf (+ (* f1-5 f1-5) (* f0-3 f0-3)))) + ) + (cond + ((>= arg2 f2-4) + (+! (-> arg0 x) f1-5) + (+! (-> arg0 z) f0-3) + ) + (else + (let ((f2-6 (/ arg2 f2-4))) + (+! (-> arg0 x) (* f2-6 f1-5)) + (+! (-> arg0 z) (* f2-6 f0-3)) + ) + ) + ) + ) + ) + ) + arg0 + ) + +(defun vector-seek-2d-yz-smooth! ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float)) + (let ((f0-1 (- (-> arg1 y) (-> arg0 y))) + (f2-1 (- (-> arg1 z) (-> arg0 z))) + ) + (when (or (!= f0-1 0.0) (!= f2-1 0.0)) + (let* ((f1-5 (* f0-1 arg3)) + (f0-3 (* f2-1 arg3)) + (f2-4 (sqrtf (+ (* f1-5 f1-5) (* f0-3 f0-3)))) + ) + (cond + ((>= arg2 f2-4) + (+! (-> arg0 y) f1-5) + (+! (-> arg0 z) f0-3) + ) + (else + (let ((f2-6 (/ arg2 f2-4))) + (+! (-> arg0 y) (* f2-6 f1-5)) + (+! (-> arg0 z) (* f2-6 f0-3)) + ) + ) + ) + ) + ) + ) + arg0 + ) + +(defun vector-seek-3d-smooth! ((arg0 vector) (arg1 vector) (arg2 float) (arg3 float)) + (let ((f0-1 (- (-> arg1 x) (-> arg0 x))) + (f1-2 (- (-> arg1 y) (-> arg0 y))) + (f3-1 (- (-> arg1 z) (-> arg0 z))) + ) + (when (or (!= f0-1 0.0) (!= f1-2 0.0) (!= f3-1 0.0)) + (let* ((f2-6 (* f0-1 arg3)) + (f1-3 (* f1-2 arg3)) + (f0-4 (* f3-1 arg3)) + (f3-5 (sqrtf (+ (* f2-6 f2-6) (* f1-3 f1-3) (* f0-4 f0-4)))) + ) + (cond + ((>= arg2 f3-5) + (+! (-> arg0 x) f2-6) + (+! (-> arg0 y) f1-3) + (+! (-> arg0 z) f0-4) + ) + (else + (let ((f3-7 (/ arg2 f3-5))) + (+! (-> arg0 x) (* f3-7 f2-6)) + (+! (-> arg0 y) (* f3-7 f1-3)) + (+! (-> arg0 z) (* f3-7 f0-4)) + ) + ) + ) + ) + ) + ) + arg0 + ) + +(defun seek-with-smooth ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float)) + (let ((f0-1 (- arg1 arg0))) + (cond + ((>= arg4 (fabs f0-1)) + arg1 + ) + (else + (let ((f0-2 (* f0-1 arg3))) + (let ((f1-4 (- arg2))) + (cond + ((< f0-2 f1-4) + (set! f0-2 f1-4) + ) + ((< arg2 f0-2) + (set! f0-2 arg2) + ) + ) + ) + (+ f0-2 arg0) + ) + ) + ) + ) + ) + +(defun vector-identity! ((arg0 vector)) + (set! (-> arg0 x) 1.0) + (set! (-> arg0 y) 1.0) + (set! (-> arg0 z) 1.0) + (set! (-> arg0 w) 1.0) + arg0 + ) + +(defun vector-seconds ((arg0 vector) (arg1 vector)) + (set! (-> arg0 x) (* 300.0 (-> arg1 x))) + (set! (-> arg0 y) (* 300.0 (-> arg1 y))) + (set! (-> arg0 z) (* 300.0 (-> arg1 z))) + arg0 + ) + +(defun vector-seconds! ((arg0 vector)) + (set! (-> arg0 x) (* 300.0 (-> arg0 x))) + (set! (-> arg0 y) (* 300.0 (-> arg0 y))) + (set! (-> arg0 z) (* 300.0 (-> arg0 z))) + arg0 + ) + +(defun vector-v! ((arg0 vector)) + (with-pp + (vector-float*! arg0 arg0 (-> pp clock seconds-per-frame)) + arg0 + ) + ) + +(defun vector-v+! ((arg0 vector) (arg1 vector) (arg2 vector)) + (with-pp + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 arg0)) + (let ((f0-0 (-> pp clock seconds-per-frame))) + (.lvf vf2 (&-> arg2 quad)) + (.lvf vf1 (&-> arg1 quad)) + (let ((a1-1 f0-0)) + (.mov vf3 a1-1) + ) + ) + (.add.x.vf vf4 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf2 vf3) + (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111) + (.svf (&-> v1-0 quad) vf4) + ) + arg0 + ) + ) + ) + +(defun vector-v*float+! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (with-pp + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 arg0)) + (let ((f0-1 (* arg3 (-> pp clock seconds-per-frame)))) + (.lvf vf2 (&-> arg2 quad)) + (.lvf vf1 (&-> arg1 quad)) + (let ((a1-1 f0-1)) + (.mov vf3 a1-1) + ) + ) + (.add.x.vf vf4 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf2 vf3) + (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111) + (.svf (&-> v1-0 quad) vf4) + ) + arg0 + ) + ) + ) +;; definition for function vector-v++! +(defun vector-v++! ((arg0 vector) (arg1 vector)) + (with-pp + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 arg0)) + (let ((a2-0 arg0) + (f0-0 (-> pp clock seconds-per-frame)) + ) + (.lvf vf2 (&-> arg1 quad)) + (.lvf vf1 (&-> a2-0 quad)) + (let ((a1-1 f0-0)) + (.mov vf3 a1-1) + ) + ) + (.add.x.vf vf4 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf2 vf3) + (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111) + (.svf (&-> v1-0 quad) vf4) + ) + arg0 + ) + ) + ) + +(defun vector-v*float! ((arg0 vector) (arg1 vector) (arg2 float)) + (with-pp + (vector-float*! arg0 arg1 (* arg2 (-> pp clock seconds-per-frame))) + ) + ) + +(defun vector-v*float++! ((arg0 vector) (arg1 vector) (arg2 float)) + (with-pp + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (let ((v1-0 arg0)) + (let ((a3-0 arg0) + (f0-1 (* arg2 (-> pp clock seconds-per-frame))) + ) + (.lvf vf2 (&-> arg1 quad)) + (.lvf vf1 (&-> a3-0 quad)) + (let ((a1-1 f0-1)) + (.mov vf3 a1-1) + ) + ) + (.add.x.vf vf4 vf0 vf0 :mask #b1000) + (.mul.x.vf acc vf2 vf3) + (.add.mul.w.vf vf4 vf1 vf0 acc :mask #b111) + (.svf (&-> v1-0 quad) vf4) + ) + arg0 + ) + ) + ) + +(defun vector-to-ups! ((arg0 vector) (arg1 vector)) + (local-vars (at-0 int)) + (with-pp + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (let ((f0-0 (-> pp clock frames-per-second))) + (.mov at-0 f0-0) + ) + (.mov vf2 at-0) + (.mov.vf vf1 vf0 :mask #b1000) + (.mul.x.vf vf1 vf1 vf2 :mask #b111) + (.svf (&-> arg0 quad) vf1) + arg0 + ) + ) + ) + +(defun vector-from-ups! ((arg0 vector) (arg1 vector)) + (local-vars (at-0 int)) + (with-pp + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (let ((f0-0 (-> pp clock seconds-per-frame))) + (.mov at-0 f0-0) + ) + (.mov vf2 at-0) + (.mov.vf vf1 vf0 :mask #b1000) + (.mul.x.vf vf1 vf1 vf2 :mask #b111) + (.svf (&-> arg0 quad) vf1) + arg0 + ) + ) + ) + +(defun vector-length ((arg0 vector)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 quad)) + (.mul.vf vf1 vf1 vf1) + (.mul.x.vf acc vf0 vf1 :mask #b1000) + (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000) + (.add.mul.z.vf vf1 vf0 vf1 acc :mask #b1000) + (.sqrt.vf Q vf1 :ftf #b11) + (.add.w.vf vf1 vf0 vf0 :mask #b1) + (.wait.vf) + (.mul.vf vf1 vf1 Q :mask #b1) + (.nop.vf) + (.nop.vf) + (.mov v0-0 vf1) + v0-0 + ) + ) + +(defun vector-length-squared ((arg0 vector)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 quad)) + (.add.w.vf vf2 vf0 vf0 :mask #b1) + (.mul.vf vf1 vf1 vf1) + (.mul.x.vf acc vf2 vf1 :mask #b1) + (.add.mul.y.vf acc vf2 vf1 acc :mask #b1) + (.add.mul.z.vf vf1 vf2 vf1 acc :mask #b1) + (.mov v0-0 vf1) + v0-0 + ) + ) + +(defun vector-xz-length-squared ((arg0 vector)) + (+ (* (-> arg0 x) (-> arg0 x)) (* (-> arg0 z) (-> arg0 z))) + ) + +(defun vector-xz-length ((arg0 vector)) + (sqrtf (+ (* (-> arg0 x) (-> arg0 x)) (* (-> arg0 z) (-> arg0 z)))) + ) + +(defun vector-vector-distance ((arg0 vector) (arg1 vector)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf2 (&-> arg0 quad)) + (.lvf vf3 (&-> arg1 quad)) + (.sub.vf vf1 vf3 vf2) + (.mul.vf vf1 vf1 vf1) + (.mul.x.vf acc vf0 vf1 :mask #b1000) + (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000) + (.add.mul.z.vf vf1 vf0 vf1 acc :mask #b1000) + (.sqrt.vf Q vf1 :ftf #b11) + (.add.w.vf vf1 vf0 vf0 :mask #b1) + (.wait.vf) + (.mul.vf vf1 vf1 Q :mask #b1) + (.nop.vf) + (.nop.vf) + (.mov v0-0 vf1) + v0-0 + ) + ) + +(defun vector-vector-distance-squared ((arg0 vector) (arg1 vector)) + (local-vars (v0-0 float)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (.lvf vf2 (&-> arg0 quad)) + (.lvf vf3 (&-> arg1 quad)) + (.sub.vf vf1 vf3 vf2) + (.mul.vf vf1 vf1 vf1) + (.add.y.vf vf1 vf1 vf1 :mask #b1) + (.add.z.vf vf1 vf1 vf1 :mask #b1) + (.mov v0-0 vf1) + v0-0 + ) + ) + +(defun vector-vector-xz-distance ((arg0 vector) (arg1 vector)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf2 (&-> arg0 quad)) + (.lvf vf3 (&-> arg1 quad)) + (.sub.vf vf1 vf3 vf2) + (.mul.vf vf1 vf1 vf1) + (.mul.x.vf acc vf0 vf1 :mask #b1000) + (.add.mul.z.vf vf1 vf0 vf1 acc :mask #b1000) + (.sqrt.vf Q vf1 :ftf #b11) + (.add.w.vf vf1 vf0 vf0 :mask #b1) + (.wait.vf) + (.mul.vf vf1 vf1 Q :mask #b1) + (.nop.vf) + (.nop.vf) + (.mov v0-0 vf1) + v0-0 + ) + ) + +(defun vector-vector-xy-distance ((arg0 vector) (arg1 vector)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf2 (&-> arg0 quad)) + (.lvf vf3 (&-> arg1 quad)) + (.sub.vf vf1 vf3 vf2) + (.mul.vf vf1 vf1 vf1) + (.mul.x.vf acc vf0 vf1 :mask #b1000) + (.add.mul.y.vf vf1 vf0 vf1 acc :mask #b1000) + (.sqrt.vf Q vf1 :ftf #b11) + (.add.w.vf vf1 vf0 vf0 :mask #b1) + (.wait.vf) + (.mul.vf vf1 vf1 Q :mask #b1) + (.nop.vf) + (.nop.vf) + (.mov v0-0 vf1) + v0-0 + ) + ) + +(defun vector-vector-xz-distance-squared ((arg0 vector) (arg1 vector)) + (local-vars (v0-0 float)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (.lvf vf2 (&-> arg0 quad)) + (.lvf vf3 (&-> arg1 quad)) + (.sub.vf vf1 vf3 vf2) + (.mul.vf vf1 vf1 vf1) + (.add.z.vf vf1 vf1 vf1 :mask #b1) + (.mov v0-0 vf1) + v0-0 + ) + ) + +(defun vector-normalize! ((arg0 vector) (arg1 float)) + "Modify arg0 in place to have length arg1 for its xyz components. The w part is not changed." + (let ((f0-0 (vector-length arg0))) + (let ((v1-1 (/ arg1 f0-0))) + (set! (-> arg0 data 0) (* (-> arg0 data 0) v1-1)) + (set! (-> arg0 data 1) (* (-> arg0 data 1) v1-1)) + (set! (-> arg0 data 2) (* (-> arg0 data 2) v1-1)) + ) + ) + arg0 + ; (rlet ((acc :class vf) + ; (Q :class vf) + ; (vf0 :class vf) + ; (vf1 :class vf) + ; (vf2 :class vf) + ; (vf3 :class vf) + ; ) + ; (init-vf0-vector) + ; (.lvf vf1 (&-> arg0 quad)) + ; (.mul.vf vf2 vf1 vf1 :mask #b111) + ; (let ((v1-0 arg1)) + ; (.mov vf3 v1-0) + ; ) + ; (.mul.x.vf acc vf0 vf2 :mask #b1000) + ; (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000) + ; (.add.mul.z.vf vf2 vf0 vf2 acc :mask #b1000) + ; (.isqrt.vf Q vf3 vf2 :fsf #b0 :ftf #b11) + ; (.wait.vf) + ; (.mul.vf vf1 vf1 Q :mask #b111) + ; (.nop.vf) + ; (.nop.vf) + ; (.nop.vf) + ; (.svf (&-> arg0 quad) vf1) + ; arg0 + ; ) + ) + +(defun vector-normalize-ret-len! ((arg0 vector) (arg1 float)) + "Modify arg0 in place to have length arg1 for its xyz components. + The w part isn't changed and the _original_ length is returned." + (let ((f0-0 (vector-length arg0))) + (let ((v1-1 (/ arg1 f0-0))) + (set! (-> arg0 data 0) (* (-> arg0 data 0) v1-1)) + (set! (-> arg0 data 1) (* (-> arg0 data 1) v1-1)) + (set! (-> arg0 data 2) (* (-> arg0 data 2) v1-1)) + ) + f0-0 + ) + + ; (local-vars (v1-1 float)) + ; (rlet ((acc :class vf) + ; (Q :class vf) + ; (vf0 :class vf) + ; (vf1 :class vf) + ; (vf2 :class vf) + ; (vf3 :class vf) + ; ) + ; (init-vf0-vector) + ; (.lvf vf1 (&-> arg0 quad)) + ; (.mul.vf vf2 vf1 vf1 :mask #b111) + ; (let ((v1-0 arg1)) + ; (.mov vf3 v1-0) + ; ) + ; (.mul.x.vf acc vf0 vf2 :mask #b1000) + ; (.add.mul.y.vf acc vf0 vf2 acc :mask #b1000) + ; (.add.mul.z.vf vf2 vf0 vf2 acc :mask #b1000) + ; (.isqrt.vf Q vf3 vf2 :fsf #b0 :ftf #b11) + ; (.add.w.vf vf2 vf0 vf2 :mask #b1) + ; (.mov v1-1 vf2) + ; (let ((v0-0 (sqrtf v1-1))) + ; (.wait.vf) + ; (.mul.vf vf1 vf1 Q :mask #b111) + ; (.nop.vf) + ; (.nop.vf) + ; (.nop.vf) + ; (.svf (&-> arg0 quad) vf1) + ; v0-0 + ; ) + ; ) + ) + +(defun vector-normalize-copy! ((arg0 vector) (arg1 vector) (arg2 float)) + (let ((f0-0 (vector-length arg1))) + (if (= f0-0 0.0) + (set! (-> arg0 quad) (-> arg1 quad)) + (let ((v1-1 (/ arg2 f0-0))) + (set! (-> arg0 data 0) (* (-> arg1 data 0) v1-1)) + (set! (-> arg0 data 1) (* (-> arg1 data 1) v1-1)) + (let ((f0-7 (* (-> arg1 data 2) v1-1))) + (set! (-> arg0 data 2) f0-7) + ) + ) + ) + ) + (set! (-> arg0 data 3) 1.0) + arg0 + ; (local-vars (v1-1 float)) + ; (rlet ((acc :class vf) + ; (Q :class vf) + ; (vf0 :class vf) + ; (vf1 :class vf) + ; ) + ; (init-vf0-vector) + ; (.lvf vf1 (&-> arg1 quad)) + ; (.mul.vf vf1 vf1 vf1) + ; (.mul.x.vf acc vf0 vf1 :mask #b1000) + ; (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000) + ; (.add.mul.z.vf vf1 vf0 vf1 acc :mask #b1000) + ; (.sqrt.vf Q vf1 :ftf #b11) + ; (.add.w.vf vf1 vf0 vf0 :mask #b1) + ; (.wait.vf) + ; (.mul.vf vf1 vf1 Q :mask #b1) + ; (.nop.vf) + ; (.nop.vf) + ; (.mov v1-1 vf1) + ; (let ((f0-0 v1-1)) + ; (cond + ; ((= f0-0 0.0) + ; (set! (-> arg0 quad) (-> arg1 quad)) + ; ) + ; (else + ; (let ((v1-3 (/ arg2 f0-0))) + ; (set! (-> arg0 x) (* (-> arg1 x) v1-3)) + ; (set! (-> arg0 y) (* (-> arg1 y) v1-3)) + ; (set! (-> arg0 z) (* (-> arg1 z) v1-3)) + ; ) + ; ) + ; ) + ; ) + ; (set! (-> arg0 w) 1.0) + ; arg0 + ; ) + ) + +(defun vector-xz-normalize! ((arg0 vector) (arg1 float)) + (let* ((v1-0 arg0) + (f0-4 (sqrtf (+ (* (-> v1-0 x) (-> v1-0 x)) (* (-> v1-0 z) (-> v1-0 z))))) + ) + (when (!= f0-4 0.0) + (let ((v1-3 (/ arg1 f0-4))) + (set! (-> arg0 x) (* (-> arg0 x) v1-3)) + (set! (-> arg0 z) (* (-> arg0 z) v1-3)) + ) + ) + ) + arg0 + ) + +(defun vector-xz-normalize-copy! ((arg0 vector) (arg1 vector) (arg2 float)) + (let* ((v1-0 arg1) + (f0-4 (sqrtf (+ (* (-> v1-0 x) (-> v1-0 x)) (* (-> v1-0 z) (-> v1-0 z))))) + ) + (cond + ((= f0-4 0.0) + (set! (-> arg0 quad) (-> arg1 quad)) + ) + (else + (let ((v1-3 (/ arg2 f0-4))) + (set! (-> arg0 x) (* (-> arg1 x) v1-3)) + (set! (-> arg0 y) 0.0) + (set! (-> arg0 z) (* (-> arg1 z) v1-3)) + ) + ) + ) + ) + (set! (-> arg0 w) 1.0) + arg0 + ) + +(defun vector-length-max! ((arg0 vector) (arg1 float)) + (local-vars (v1-1 float)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf1 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 quad)) + (.mul.vf vf1 vf1 vf1) + (.mul.x.vf acc vf0 vf1 :mask #b1000) + (.add.mul.y.vf acc vf0 vf1 acc :mask #b1000) + (.add.mul.z.vf vf1 vf0 vf1 acc :mask #b1000) + (.sqrt.vf Q vf1 :ftf #b11) + (.add.w.vf vf1 vf0 vf0 :mask #b1) + (.wait.vf) + (.mul.vf vf1 vf1 Q :mask #b1) + (.nop.vf) + (.nop.vf) + (.mov v1-1 vf1) + (let ((f0-0 v1-1)) + (when (not (or (= f0-0 0.0) (< f0-0 arg1))) + (let ((f0-1 (/ f0-0 arg1))) + (when (!= f0-1 0.0) + (set! (-> arg0 x) (/ (-> arg0 x) f0-1)) + (set! (-> arg0 y) (/ (-> arg0 y) f0-1)) + (set! (-> arg0 z) (/ (-> arg0 z) f0-1)) + ) + ) + ) + ) + arg0 + ) + ) + +(defun vector-xz-length-max! ((arg0 vector) (arg1 float)) + (let* ((v1-0 arg0) + (f0-4 (sqrtf (+ (* (-> v1-0 x) (-> v1-0 x)) (* (-> v1-0 z) (-> v1-0 z))))) + ) + (when (not (or (= f0-4 0.0) (< f0-4 arg1))) + (let ((f0-5 (/ f0-4 arg1))) + (when (!= f0-5 0.0) + (set! (-> arg0 x) (/ (-> arg0 x) f0-5)) + (set! (-> arg0 z) (/ (-> arg0 z) f0-5)) + ) + ) + ) + ) + arg0 + ) + +(defun vector-rotate-around-x! ((arg0 vector) (arg1 vector) (arg2 float)) + (let* ((f28-0 (- arg2)) + (f30-0 (cos f28-0)) + (f1-0 (sin f28-0)) + (f2-0 (-> arg1 z)) + (f0-1 (-> arg1 y)) + ) + (set! (-> arg0 quad) (-> arg1 quad)) + (set! (-> arg0 z) (- (* f2-0 f30-0) (* f0-1 f1-0))) + (set! (-> arg0 y) (+ (* f2-0 f1-0) (* f0-1 f30-0))) + ) + arg0 + ) + +(defun vector-rotate-around-y! ((arg0 vector) (arg1 vector) (arg2 float)) + (let ((f26-0 (-> arg1 z)) + (f30-0 (-> arg1 x)) + (f28-0 (cos arg2)) + (f0-0 (sin arg2)) + ) + (set! (-> arg0 quad) (-> arg1 quad)) + (set! (-> arg0 z) (- (* f26-0 f28-0) (* f30-0 f0-0))) + (set! (-> arg0 x) (+ (* f26-0 f0-0) (* f30-0 f28-0))) + ) + arg0 + ) + +(defun vector-rotate90-around-y! ((arg0 vector) (arg1 vector)) + (set! (-> arg0 quad) (-> arg1 quad)) + (let ((f0-0 (-> arg0 x))) + (set! (-> arg0 x) (- (-> arg1 z))) + (set! (-> arg0 z) f0-0) + ) + arg0 + ) + +(defun vector-rotate-around-z! ((arg0 vector) (arg1 vector) (arg2 float)) + (let ((f26-0 (-> arg1 x)) + (f30-0 (-> arg1 y)) + (f28-0 (cos arg2)) + (f0-0 (sin arg2)) + ) + (set! (-> arg0 quad) (-> arg1 quad)) + (set! (-> arg0 x) (- (* f26-0 f28-0) (* f30-0 f0-0))) + (set! (-> arg0 y) (+ (* f26-0 f0-0) (* f30-0 f28-0))) + ) + arg0 + ) + +(defun rotate-y<-vector+vector ((arg0 vector) (arg1 vector)) + (atan (- (-> arg1 x) (-> arg0 x)) (- (-> arg1 z) (-> arg0 z))) + ) + +(defun rotate-x<-vector+vector ((arg0 vector) (arg1 vector)) + (atan (- (-> arg1 y) (-> arg0 y)) (- (-> arg1 z) (-> arg0 z))) + ) + +(defun rotate-z<-vector+vector ((arg0 vector) (arg1 vector)) + (atan (- (-> arg1 x) (-> arg0 x)) (- (-> arg1 y) (-> arg0 y))) + ) + +(defun vector-cvt.w.s! ((arg0 vector) (arg1 vector)) + (rlet ((vf1 :class vf)) + (.lvf vf1 (&-> arg1 quad)) + (.ftoi.vf vf1 vf1) + (.svf (&-> arg0 quad) vf1) + arg0 + ) + ) + +;; definition for function vector-cvt.s.w! +(defun vector-cvt.s.w! ((arg0 vector) (arg1 vector)) + (rlet ((vf1 :class vf)) + (.lvf vf1 (&-> arg1 quad)) + (.itof.vf vf1 vf1) + (.svf (&-> arg0 quad) vf1) + arg0 + ) + ) + +(defun rot-zxy-from-vector! ((arg0 vector) (arg1 vector)) + (let* ((f28-0 (-> arg1 z)) + (f30-0 (-> arg1 x)) + (f0-0 (atan f30-0 f28-0)) + ) + (set! (-> arg0 y) f0-0) + (let* ((f26-0 (- f0-0)) + (f0-4 (- (* f28-0 (cos f26-0)) (* f30-0 (sin f26-0)))) + ) + (set! (-> arg0 x) (atan (- (-> arg1 y)) f0-4)) + ) + ) + (set! (-> arg0 z) 0.0) + arg0 + ) + +(defun rot-zyx-from-vector! ((arg0 vector) (arg1 vector)) + (let* ((f28-0 (-> arg1 z)) + (f30-0 (- (-> arg1 y))) + (f0-1 (atan f30-0 f28-0)) + ) + (set! (-> arg0 x) f0-1) + (let* ((f26-0 (- f0-1)) + (f0-5 (- (* f28-0 (cos f26-0)) (* f30-0 (sin f26-0)))) + ) + (set! (-> arg0 y) (atan (-> arg1 x) f0-5)) + ) + ) + (set! (-> arg0 z) 0.0) + arg0 + ) + +(defun vector-lerp! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.mov vf4 arg3) + (.add.x.vf vf3 vf0 vf0 :mask #b1000) + (.sub.vf vf2 vf2 vf1) + (.mul.x.vf vf2 vf2 vf4) + (.add.vf vf3 vf1 vf2 :mask #b111) + (.svf (&-> arg0 quad) vf3) + arg0 + ) + ) + +(defun vector-lerp-clamp! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (cond + ((>= 0.0 arg3) + (set! (-> arg0 quad) (-> arg1 quad)) + ) + ((>= arg3 1.0) + (set! (-> arg0 quad) (-> arg2 quad)) + ) + (else + (let ((v1-3 arg0)) + (let ((f0-2 arg3)) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (let ((a1-1 f0-2)) + (.mov vf4 a1-1) + ) + ) + (.add.x.vf vf3 vf0 vf0 :mask #b1000) + (.sub.vf vf2 vf2 vf1) + (.mul.x.vf vf2 vf2 vf4) + (.add.vf vf3 vf1 vf2 :mask #b111) + (.svf (&-> v1-3 quad) vf3) + ) + ) + ) + arg0 + ) + ) + +(defun vector4-lerp! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.mov vf4 arg3) + (.sub.vf vf2 vf2 vf1) + (.mul.x.vf vf2 vf2 vf4) + (.add.vf vf3 vf1 vf2) + (.svf (&-> arg0 quad) vf3) + arg0 + ) + ) + +(defun vector4-lerp-clamp! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (cond + ((>= 0.0 arg3) + (set! (-> arg0 quad) (-> arg1 quad)) + ) + ((>= arg3 1.0) + (set! (-> arg0 quad) (-> arg2 quad)) + ) + (else + (let ((v1-3 arg0)) + (let ((f0-2 arg3)) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (let ((a1-1 f0-2)) + (.mov vf4 a1-1) + ) + ) + (.sub.vf vf2 vf2 vf1) + (.mul.x.vf vf2 vf2 vf4) + (.add.vf vf3 vf1 vf2) + (.svf (&-> v1-3 quad) vf3) + ) + ) + ) + arg0 + ) + ) + +(defun vector-degi ((arg0 vector) (arg1 vector)) + (local-vars (v1-0 uint128) (v1-1 uint128)) + (rlet ((vf1 :class vf)) + (.lvf vf1 (&-> arg1 quad)) + (.ftoi.vf vf1 vf1) + (.mov v1-0 vf1) + (.pw.sll v1-1 v1-0 16) + (set! (-> arg0 quad) v1-1) + arg0 + ) + ) + +(defun vector-degf ((arg0 vector) (arg1 vector)) + (local-vars (v1-1 uint128)) + (rlet ((vf1 :class vf)) + (let ((v1-0 (-> arg1 quad))) + (.pw.sra v1-1 v1-0 16) + ) + (.mov vf1 v1-1) + (.itof.vf vf1 vf1) + (.svf (&-> arg0 quad) vf1) + arg0 + ) + ) + +(defun vector-degmod ((arg0 vector) (arg1 vector)) + (local-vars (v1-0 uint128) (v1-1 uint128) (v1-2 uint128)) + (rlet ((vf1 :class vf)) + (.lvf vf1 (&-> arg1 quad)) + (.ftoi.vf vf1 vf1) + (.mov v1-0 vf1) + (.pw.sll v1-1 v1-0 16) + (.pw.sra v1-2 v1-1 16) + (.mov vf1 v1-2) + (.itof.vf vf1 vf1) + (.svf (&-> arg0 quad) vf1) + arg0 + ) + ) + +(defun vector-deg-diff ((arg0 vector) (arg1 vector) (arg2 vector)) + (local-vars + (v0-0 float) + (v1-0 uint128) + (v1-1 uint128) + (v1-2 uint128) + (v1-3 uint128) + (a1-1 uint128) + (a1-2 uint128) + ) + (rlet ((vf1 :class vf) + (vf2 :class vf) + ) + (.lvf vf1 (&-> arg1 quad)) + (.lvf vf2 (&-> arg2 quad)) + (.ftoi.vf vf1 vf1) + (.ftoi.vf vf2 vf2) + (.mov a1-1 vf1) + (.mov v1-0 vf2) + (.pw.sll a1-2 a1-1 16) + (.pw.sll v1-1 v1-0 16) + (.psubw v1-2 a1-2 v1-1) + (.pw.sra v1-3 v1-2 16) + (.mov vf1 v1-3) + (.itof.vf vf1 vf1) + (.svf (&-> arg0 quad) vf1) + (.mov v0-0 vf1) + (none) + ) + ) + +(defun vector-deg-lerp-clamp! ((arg0 vector) (arg1 vector) (arg2 vector) (arg3 float)) + (cond + ((>= 0.0 arg3) + (set! (-> arg0 quad) (-> arg1 quad)) + ) + ((>= arg3 1.0) + (set! (-> arg0 quad) (-> arg2 quad)) + ) + (else + (set! (-> arg0 x) (deg-lerp-clamp (-> arg1 x) (-> arg2 x) arg3)) + (set! (-> arg0 y) (deg-lerp-clamp (-> arg1 y) (-> arg2 y) arg3)) + (set! (-> arg0 z) (deg-lerp-clamp (-> arg1 z) (-> arg2 z) arg3)) + (set! (-> arg0 w) 1.0) + ) + ) + arg0 + ) + +(defun vector3s-copy! ((arg0 vector) (arg1 vector)) + "Copy a vector3s" + (set! (-> arg0 x) (-> arg1 x)) + (set! (-> arg0 y) (-> arg1 y)) + (set! (-> arg0 z) (-> arg1 z)) + arg0 + ) + +(defun vector3s+! ((arg0 vector) (arg1 vector) (arg2 vector)) + "Add 2 vectors3." + (set! (-> arg0 x) (+ (-> arg1 x) (-> arg2 x))) + (set! (-> arg0 y) (+ (-> arg1 y) (-> arg2 y))) + (set! (-> arg0 z) (+ (-> arg1 z) (-> arg2 z))) + arg0 + ) + +(defun vector3s*float! ((arg0 vector) (arg1 vector) (arg2 float)) + "mult vectors3 by float" + (set! (-> arg0 x) (* (-> arg1 x) arg2)) + (set! (-> arg0 y) (* (-> arg1 y) arg2)) + (set! (-> arg0 z) (* (-> arg1 z) arg2)) + arg0 + ) + +(defun vector3s-! ((arg0 vector) (arg1 vector) (arg2 vector)) + "Subtract 2 vectors3: c = (a - b)." + (set! (-> arg0 x) (- (-> arg1 x) (-> arg2 x))) + (set! (-> arg0 y) (- (-> arg1 y) (-> arg2 y))) + (set! (-> arg0 z) (- (-> arg1 z) (-> arg2 z))) + arg0 + ) + +(defun vector4-add! ((arg0 vector4) (arg1 vector4) (arg2 vector4)) + (local-vars (v0-0 float)) + (rlet ((vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (.lvf vf5 (&-> arg1 quad)) + (.lvf vf6 (&-> arg2 quad)) + (.add.vf vf4 vf5 vf6) + (.svf (&-> arg0 quad) vf4) + (.mov v0-0 vf4) + (none) + ) + ) + +(defun vector4-sub! ((arg0 vector4) (arg1 vector4) (arg2 vector4)) + (local-vars (v0-0 float)) + (rlet ((vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (.lvf vf5 (&-> arg1 quad)) + (.lvf vf6 (&-> arg2 quad)) + (.sub.vf vf4 vf5 vf6) + (.svf (&-> arg0 quad) vf4) + (.mov v0-0 vf4) + (none) + ) + ) + +(defun vector4-mul! ((arg0 vector4) (arg1 vector4) (arg2 vector4)) + (local-vars (v0-0 float)) + (rlet ((vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (.lvf vf5 (&-> arg1 quad)) + (.lvf vf6 (&-> arg2 quad)) + (.mul.vf vf4 vf5 vf6) + (.svf (&-> arg0 quad) vf4) + (.mov v0-0 vf4) + (none) + ) + ) + +(defun vector4-scale! ((arg0 vector4) (arg1 vector4) (arg2 float)) + (local-vars (v0-0 float)) + (rlet ((vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + ) + (.mov vf6 arg2) + (.lvf vf5 (&-> arg1 quad)) + (.mul.x.vf vf4 vf5 vf6) + (.svf (&-> arg0 quad) vf4) + (.mov v0-0 vf4) + (none) + ) + ) + +(defun vector4-madd! ((arg0 vector4) (arg1 vector4) (arg2 vector4) (arg3 float)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (init-vf0-vector) + (.mov vf7 arg3) + (.lvf vf5 (&-> arg1 quad)) + (.lvf vf6 (&-> arg2 quad)) + (.mul.w.vf acc vf5 vf0) + (.add.mul.x.vf vf4 vf6 vf7 acc) + (.svf (&-> arg0 quad) vf4) + (.mov v0-0 vf4) + (none) + ) + ) + +(defun vector4-msub! ((arg0 vector4) (arg1 vector4) (arg2 vector4) (arg3 float)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + ) + (init-vf0-vector) + (.mov vf7 arg3) + (.lvf vf5 (&-> arg1 quad)) + (.lvf vf6 (&-> arg2 quad)) + (.mul.w.vf acc vf5 vf0) + (.sub.mul.x.vf vf4 vf6 vf7 acc) + (.svf (&-> arg0 quad) vf4) + (.mov v0-0 vf4) + (none) + ) + ) + +(defun vector4-array-add! ((arg0 (inline-array vector4)) (arg1 (inline-array vector4)) (arg2 (inline-array vector4)) (arg3 int)) + (dotimes (s2-0 arg3) + (vector4-add! (the-as vector4 arg0) (the-as vector4 arg1) (the-as vector4 arg2)) + (set! arg1 (the-as (inline-array vector4) (-> arg1 1))) + (set! arg2 (the-as (inline-array vector4) (-> arg2 1))) + (set! arg0 (the-as (inline-array vector4) (-> arg0 1))) + ) + (none) + ) + +(defun vector4-array-sub! ((arg0 (inline-array vector4)) (arg1 (inline-array vector4)) (arg2 (inline-array vector4)) (arg3 int)) + (dotimes (s2-0 arg3) + (vector4-sub! (the-as vector4 arg0) (the-as vector4 arg1) (the-as vector4 arg2)) + (set! arg1 (the-as (inline-array vector4) (-> arg1 1))) + (set! arg2 (the-as (inline-array vector4) (-> arg2 1))) + (set! arg0 (the-as (inline-array vector4) (-> arg0 1))) + ) + (none) + ) + +(defun vector4-array-mul! ((arg0 (inline-array vector4)) (arg1 (inline-array vector4)) (arg2 (inline-array vector4)) (arg3 int)) + (dotimes (s2-0 arg3) + (vector4-mul! (the-as vector4 arg0) (the-as vector4 arg1) (the-as vector4 arg2)) + (set! arg1 (the-as (inline-array vector4) (-> arg1 1))) + (set! arg2 (the-as (inline-array vector4) (-> arg2 1))) + (set! arg0 (the-as (inline-array vector4) (-> arg0 1))) + ) + (none) + ) + +(defun vector4-array-scale! ((arg0 (inline-array vector4)) (arg1 (inline-array vector4)) (arg2 float) (arg3 int)) + (dotimes (s2-0 arg3) + (vector4-scale! (the-as vector4 arg0) (the-as vector4 arg1) arg2) + (set! arg1 (the-as (inline-array vector4) (-> arg1 1))) + (set! arg0 (the-as (inline-array vector4) (-> arg0 1))) + ) + (none) + ) + +(defun vector4-array-madd! ((arg0 (inline-array vector4)) + (arg1 (inline-array vector4)) + (arg2 (inline-array vector4)) + (arg3 float) + (arg4 int) + ) + (dotimes (s1-0 arg4) + (vector4-madd! (the-as vector4 arg0) (the-as vector4 arg1) (the-as vector4 arg2) arg3) + (set! arg1 (the-as (inline-array vector4) (-> arg1 1))) + (set! arg2 (the-as (inline-array vector4) (-> arg2 1))) + (set! arg0 (the-as (inline-array vector4) (-> arg0 1))) + ) + (none) + ) + +(defun vector4-array-msub! ((arg0 (inline-array vector4)) + (arg1 (inline-array vector4)) + (arg2 (inline-array vector4)) + (arg3 float) + (arg4 int) + ) + (dotimes (s1-0 arg4) + (vector4-msub! (the-as vector4 arg0) (the-as vector4 arg1) (the-as vector4 arg2) arg3) + (set! arg1 (the-as (inline-array vector4) (-> arg1 1))) + (set! arg2 (the-as (inline-array vector4) (-> arg2 1))) + (set! arg0 (the-as (inline-array vector4) (-> arg0 1))) + ) + (none) + ) + +(defun vector4-array-lerp! ((arg0 (inline-array vector4)) + (arg1 (inline-array vector4)) + (arg2 (inline-array vector4)) + (arg3 float) + (arg4 int) + ) + (dotimes (s1-0 arg4) + (vector4-lerp! (the-as vector arg0) (the-as vector arg1) (the-as vector arg2) arg3) + (set! arg1 (the-as (inline-array vector4) (-> arg1 1))) + (set! arg2 (the-as (inline-array vector4) (-> arg2 1))) + (set! arg0 (the-as (inline-array vector4) (-> arg0 1))) + ) + (none) + ) + +(defun spheres-overlap? ((arg0 sphere) (arg1 sphere)) + (local-vars (v1-0 float) (a0-1 float)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 quad)) + (.lvf vf2 (&-> arg1 quad)) + (.sub.vf vf3 vf1 vf2 :mask #b111) + (.mul.vf vf3 vf3 vf3 :mask #b111) + (.add.w.vf vf4 vf1 vf2 :mask #b1000) + (.mul.w.vf vf4 vf4 vf4 :mask #b1000) + (.add.y.vf vf3 vf3 vf3 :mask #b1) + (.add.z.vf vf3 vf3 vf3 :mask #b1) + (.add.w.vf vf4 vf0 vf4 :mask #b1) + (.mov a0-1 vf4) + (.mov v1-0 vf3) + (>= a0-1 v1-0) + ) + ) + +(defun sphere<-vector! ((arg0 sphere) (arg1 vector)) + (let ((f0-0 (-> arg0 w))) + (set! (-> arg0 quad) (-> arg1 quad)) + (set! (-> arg0 w) f0-0) + ) + arg0 + ) + +(defun sphere<-vector+r! ((arg0 sphere) (arg1 vector) (arg2 float)) + (set! (-> arg0 quad) (-> arg1 quad)) + (set! (-> arg0 w) arg2) + arg0 + ) + +(defun rand-vu-sphere-point! ((arg0 vector) (arg1 float)) + (set-vector! + arg0 + (rand-vu-float-range -1.0 1.0) + (rand-vu-float-range -1.0 1.0) + (rand-vu-float-range -1.0 1.0) + 1.0 + ) + (vector-normalize! arg0 (rand-vu-float-range 0.0 arg1)) + ) + +(defmethod print vector2 ((obj vector2)) + (format #t "#" (-> obj x) (-> obj y) obj) + obj + ) + +(defun vector-vector-angle-safe ((arg0 vector) (arg1 vector)) + (let ((f0-1 (vector-dot + (vector-normalize-copy! (new 'stack-no-clear 'vector) arg0 1.0) + (vector-normalize-copy! (new 'stack-no-clear 'vector) arg1 1.0) + ) + ) + ) + (the-as float (cond + ((>= f0-1 1.0) + 0 + ) + ((>= -1.0 f0-1) + #x3c8d5f25 + ) + (else + (acos f0-1) + ) + ) + ) + ) + ) + + + + diff --git a/goal_src/jak2/engine/ps2/pad.gc b/goal_src/jak2/engine/ps2/pad.gc index 11d4ee871b..b5613db688 100644 --- a/goal_src/jak2/engine/ps2/pad.gc +++ b/goal_src/jak2/engine/ps2/pad.gc @@ -5,3 +5,631 @@ ;; name in dgo: pad ;; dgos: ENGINE, GAME +(define-extern get-current-time (function time-frame)) +(define-extern get-integral-current-time (function time-frame)) +(define-extern get-current-language (function language-enum)) +(define-extern add-debug-cursor (function symbol bucket-id int int int none)) + + +(defenum pad-buttons + :bitfield #t + :type uint32 + (select 0) + (l3 1) + (r3 2) + (start 3) + (up 4) + (right 5) + (down 6) + (left 7) + (l2 8) + (r2 9) + (l1 10) + (r1 11) + (triangle 12) + (circle 13) + (x 14) + (square 15) + ) + +(deftype scf-time (structure) + ((stat uint8 :offset-assert 0) + (second uint8 :offset-assert 1) + (minute uint8 :offset-assert 2) + (hour uint8 :offset-assert 3) + (week uint8 :offset-assert 4) + (day uint8 :offset-assert 5) + (month uint8 :offset-assert 6) + (year uint8 :offset-assert 7) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(define *cheat-mode* #t) + +(deftype hw-cpad (basic) + ((valid uint8 :offset-assert 4) + (status uint8 :offset-assert 5) + (button0 uint16 :offset-assert 6) + (rightx uint8 :offset-assert 8) + (righty uint8 :offset-assert 9) + (leftx uint8 :offset-assert 10) + (lefty uint8 :offset-assert 11) + (abutton uint8 12 :offset-assert 12) + (dummy uint8 12 :offset-assert 24) + ) + :method-count-assert 9 + :size-assert #x24 + :flag-assert #x900000024 + ) + +(deftype cpad-info (hw-cpad) + ((number int32 :offset-assert 36) + (cpad-file int32 :offset-assert 40) + (button0-abs pad-buttons 3 :offset-assert 44) + (button0-shadow-abs pad-buttons 1 :offset-assert 56) + (button0-rel pad-buttons 3 :offset-assert 60) + (stick0-dir float :offset-assert 72) + (stick0-speed float :offset-assert 76) + (new-pad int32 :offset-assert 80) + (state int32 :offset-assert 84) + (align uint8 6 :offset-assert 88) + (direct uint8 6 :offset-assert 94) + (buzz-val uint8 2 :offset-assert 100) + (buzz-pause-val uint8 1 :offset-assert 102) + (buzz-pause-time uint8 :offset-assert 103) + (buzz-time time-frame 2 :offset-assert 104) + (buzz basic :offset-assert 120) + (buzz-act int32 :offset-assert 124) + (change-time uint64 :offset-assert 128) + (old-rightx uint8 2 :offset-assert 136) + (old-righty uint8 2 :offset-assert 138) + (old-leftx uint8 2 :offset-assert 140) + (old-lefty uint8 2 :offset-assert 142) + ) + :method-count-assert 10 + :size-assert #x90 + :flag-assert #xa00000090 + (:methods + (new (symbol type int) _type_ 0) + (dummy-9 () none 9) + ) + ) + + +(defun cpad-invalid! ((arg0 cpad-info)) + (logior! (-> arg0 valid) 128) + (set! (-> arg0 button0) (the-as uint 0)) + (set! (-> arg0 button0-abs 0) (pad-buttons)) + (set! (-> arg0 button0-shadow-abs 0) (pad-buttons)) + (set! (-> arg0 button0-rel 0) (pad-buttons)) + (dotimes (v1-2 12) + (nop!) + (set! (-> arg0 abutton v1-2) (the-as uint 0)) + ) + (set! (-> arg0 stick0-dir) 0.0) + (set! (-> arg0 stick0-speed) 0.0) + (set! (-> arg0 rightx) (the-as uint 128)) + (set! (-> arg0 righty) (the-as uint 128)) + (set! (-> arg0 leftx) (the-as uint 128)) + (set! (-> arg0 lefty) (the-as uint 128)) + (set! (-> arg0 align 0) (the-as uint 0)) + (set! (-> arg0 align 1) (the-as uint 1)) + (set! (-> arg0 align 2) (the-as uint 255)) + (set! (-> arg0 align 3) (the-as uint 255)) + (set! (-> arg0 align 4) (the-as uint 255)) + (set! (-> arg0 align 5) (the-as uint 255)) + (dotimes (v1-14 6) + (nop!) + (set! (-> arg0 direct v1-14) (the-as uint 0)) + ) + (dotimes (v1-17 2) + (nop!) + (set! (-> arg0 buzz-val v1-17) (the-as uint 0)) + (set! (-> arg0 buzz-time v1-17) 0) + ) + (set! (-> arg0 buzz-pause-val 0) (the-as uint 0)) + (set! (-> arg0 buzz-time 0) 0) + arg0 + ) + +(defmethod new cpad-info ((allocation symbol) (type-to-make type) (arg0 int)) + (let ((s5-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (set! (-> s5-0 number) arg0) + (set! (-> s5-0 buzz) #f) + (cpad-open s5-0 arg0) + (cpad-invalid! s5-0) + ) + ) + +(deftype cpad-list (basic) + ((num-cpads int32 :offset-assert 4) + (cpads cpad-info 2 :offset-assert 8) + ) + (:methods + (new (symbol type) _type_ 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(defmethod new cpad-list ((allocation symbol) (type-to-make type)) + (let ((gp-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (set! (-> gp-0 num-cpads) 2) + (set! (-> gp-0 cpads 0) (new 'global 'cpad-info 0)) + (set! (-> gp-0 cpads 1) (new 'global 'cpad-info 1)) + gp-0 + ) + ) + +(defun analog-input ((arg0 int) (arg1 float) (arg2 float) (arg3 float) (arg4 float)) + (let* ((f1-1 (- (the float arg0) arg1)) + (f0-3 (- (fabs f1-1) arg2)) + (v1-0 (- arg3 arg2)) + ) + (if (< f1-1 0.0) + (set! arg4 (- arg4)) + ) + (the-as float (cond + ((>= 0.0 f0-3) + 0 + ) + ((>= f0-3 v1-0) + arg4 + ) + (else + (/ (* f0-3 arg4) v1-0) + ) + ) + ) + ) + ) + +(defun cpad-set-buzz! ((arg0 cpad-info) (arg1 int) (arg2 int) (arg3 time-frame)) + (cond + ((zero? arg2) + (set! (-> arg0 buzz-val arg1) (the-as uint 0)) + 0 + ) + ((= arg2 (-> arg0 buzz-val arg1)) + (set! (-> arg0 buzz-time arg1) (max (-> arg0 buzz-time arg1) (+ (get-current-time) arg3))) + ) + ((< (-> arg0 buzz-val arg1) (the-as uint arg2)) + (set! (-> arg0 buzz-val arg1) (the-as uint arg2)) + (set! (-> arg0 buzz-time arg1) (+ (get-current-time) arg3)) + ) + ) + 0 + (none) + ) + +(define *cpad-list* (new 'global 'cpad-list)) + +(define *cpad-debug* #f) + +(defun service-cpads () + (let ((gp-0 *cpad-list*)) + (dotimes (s5-0 (-> gp-0 num-cpads)) + (let ((s4-0 (-> *cpad-list* cpads s5-0))) + (set! (-> s4-0 old-leftx 1) (-> s4-0 old-leftx 0)) + (set! (-> s4-0 old-leftx 0) (-> s4-0 leftx)) + (set! (-> s4-0 old-lefty 1) (-> s4-0 old-lefty 0)) + (set! (-> s4-0 old-lefty 0) (-> s4-0 lefty)) + (set! (-> s4-0 old-rightx 1) (-> s4-0 old-rightx 0)) + (set! (-> s4-0 old-rightx 0) (-> s4-0 rightx)) + (set! (-> s4-0 old-righty 1) (-> s4-0 old-righty 0)) + (set! (-> s4-0 old-righty 0) (-> s4-0 righty)) + (cpad-get-data s4-0) + ((method-of-object s4-0 dummy-9)) + (cond + ((zero? (logand (-> s4-0 valid) 128)) + (dotimes (s3-0 2) + (cond + ((and (-> s4-0 buzz) (< (get-current-time) (-> s4-0 buzz-time s3-0)) (= *master-mode* 'game)) + (let ((v1-20 s3-0)) + (cond + ((zero? v1-20) + (set! (-> s4-0 direct s3-0) + (logand (ash (-> s4-0 buzz-val s3-0) (- (the-as int (logand (get-integral-current-time) 7)))) 1) + ) + ) + ((= v1-20 1) + (set! (-> s4-0 direct s3-0) (-> s4-0 buzz-val s3-0)) + ) + ) + ) + ) + ((and (zero? s3-0) (> (-> s4-0 buzz-pause-time) 0)) + (set! (-> s4-0 direct s3-0) + (logand (ash (-> s4-0 buzz-pause-val s3-0) (- (the-as int (logand (get-integral-current-time) 7)))) 1) + ) + (+! (-> s4-0 buzz-pause-time) -1) + ) + (else + (set! (-> s4-0 buzz-val s3-0) (the-as uint 0)) + (set! (-> s4-0 direct s3-0) (the-as uint 0)) + (when (zero? s3-0) + (set! (-> s4-0 buzz-pause-time) (the-as uint 0)) + 0 + ) + ) + ) + ) + (when (< (the-as uint 192) (-> s4-0 direct 1)) + (set! (-> s4-0 direct 0) (the-as uint 0)) + 0 + ) + (set! (-> s4-0 button0-abs 2) (-> s4-0 button0-abs 1)) + (set! (-> s4-0 button0-abs 1) (-> s4-0 button0-shadow-abs 0)) + (set! (-> s4-0 button0-rel 2) (-> s4-0 button0-rel 1)) + (set! (-> s4-0 button0-rel 1) (-> s4-0 button0-rel 0)) + ;; what is going on here + (when (= (-> s4-0 status) 115) + (set! (-> s4-0 abutton 0) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons right)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 1) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons left)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 2) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons up)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 3) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons down)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 6) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons x)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 5) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons circle)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 4) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons triangle)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 7) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons square)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 8) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons l1)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 10) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons l2)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 9) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons r1)) + 255 + 0 + ) + ) + ) + (set! (-> s4-0 abutton 11) (the-as uint (if (logtest? (-> s4-0 button0-abs 0) (pad-buttons r2)) + 255 + 0 + ) + ) + ) + ) + ;; what's this + (let ((s3-1 (the int (-> s4-0 button0)))) + (cond + ((< (-> s4-0 lefty) (the-as uint 30)) + (set! s3-1 (logior #x10000 s3-1)) + ) + ((< (the-as uint 225) (-> s4-0 lefty)) + (set! s3-1 (logior #x40000 s3-1)) + ) + ) + (cond + ((< (-> s4-0 leftx) (the-as uint 30)) + (set! s3-1 (logior #x80000 s3-1)) + ) + ((< (the-as uint 225) (-> s4-0 leftx)) + (set! s3-1 (logior #x20000 s3-1)) + ) + ) + (cond + ((< (-> s4-0 righty) (the-as uint 30)) + (set! s3-1 (logior #x100000 s3-1)) + ) + ((< (the-as uint 225) (-> s4-0 righty)) + (set! s3-1 (logior #x400000 s3-1)) + ) + ) + (cond + ((< (-> s4-0 rightx) (the-as uint 30)) + (set! s3-1 (logior #x800000 s3-1)) + ) + ((< (the-as uint 225) (-> s4-0 rightx)) + (set! s3-1 (logior #x200000 s3-1)) + ) + ) + (let ((v1-123 (get-current-language))) + (cond + ((or (= v1-123 (language-enum japanese)) (= v1-123 (language-enum uk-english))) + (case (scf-get-territory) + ((2 3) + (if (logtest? s3-1 8192) + (set! s3-1 (logior #x1000000 s3-1)) + ) + ) + (else + (if (logtest? s3-1 #x6000) + (set! s3-1 (logior #x1000000 s3-1)) + ) + ) + ) + ) + ((let ((v1-135 (scf-get-territory))) + (or (= v1-135 2) (= v1-135 3)) + ) + (if (logtest? s3-1 #x6000) + (set! s3-1 (logior #x1000000 s3-1)) + ) + ) + (else + (if (logtest? s3-1 #x4000) + (set! s3-1 (logior #x1000000 s3-1)) + ) + ) + ) + ) + (set! (-> s4-0 button0-shadow-abs 0) (the-as pad-buttons s3-1)) + (set! (-> s4-0 button0-abs 0) (the-as pad-buttons s3-1)) + ) + (set! (-> s4-0 button0-rel 0) (logclear (-> s4-0 button0-abs 0) (-> s4-0 button0-abs 1))) + (when *cpad-debug* + (set! (-> s4-0 leftx) (the-as uint 255)) + (set! (-> s4-0 rightx) (the-as uint 255)) + ) + (set! (-> s4-0 stick0-speed) 1.0) + (cond + ((= (shr (-> s4-0 status) 4) 7) + (let ((f30-0 (* 0.0078125 (the float (+ (-> s4-0 leftx) -128)))) + (f28-0 (* 0.0078125 (the float (- 127 (the-as int (-> s4-0 lefty)))))) + ) + (set! (-> s4-0 stick0-dir) (atan (- f30-0) f28-0)) + (set! (-> s4-0 stick0-speed) (fmin 1.0 (sqrtf (+ (* f30-0 f30-0) (* f28-0 f28-0))))) + ) + (if (< (-> s4-0 stick0-speed) 0.3) + (set! (-> s4-0 stick0-speed) 0.0) + ) + ) + (else + (set! (-> s4-0 leftx) (the-as uint 128)) + (set! (-> s4-0 lefty) (the-as uint 128)) + (set! (-> s4-0 rightx) (the-as uint 128)) + (set! (-> s4-0 righty) (the-as uint 128)) + (set! (-> s4-0 stick0-dir) 0.0) + (set! (-> s4-0 stick0-speed) 0.0) + ) + ) + (if (or (!= (-> s4-0 button0-abs 0) (-> s4-0 button0-abs 1)) + (or (< 0.3 (-> s4-0 stick0-speed)) (zero? (-> s4-0 change-time))) + ) + (set! (-> s4-0 change-time) (the-as uint (get-current-time))) + ) + ) + (else + (cpad-invalid! s4-0) + ) + ) + ) + ) + ) + *cpad-list* + ) + +(defun buzz-stop! ((arg0 int)) + (cpad-set-buzz! (-> *cpad-list* cpads arg0) 0 0 0) + (cpad-set-buzz! (-> *cpad-list* cpads arg0) 1 0 0) + 0 + (none) + ) + +(deftype mouse-info (basic) + ((active symbol :offset-assert 4) + (cursor basic :offset-assert 8) + (valid symbol :offset-assert 12) + (id uint8 :offset-assert 16) + (status uint16 :offset-assert 18) + (button0 uint16 :offset-assert 20) + (deltax int8 :offset-assert 22) + (deltay int8 :offset-assert 23) + (wheel uint8 :offset-assert 24) + (change-time time-frame :offset-assert 32) + (button0-abs uint32 3 :offset-assert 40) + (button0-shadow-abs uint32 1 :offset-assert 52) + (button0-rel uint32 3 :offset-assert 56) + (pos vector 2 :inline :offset-assert 80) + (posx float :offset 80) + (posy float :offset 84) + (oldposx float :offset 96) + (oldposy float :offset 100) + (speedx float :offset 92) + (speedy float :offset 108) + ) + (:methods + (new (symbol type) _type_ 0) + ) + :method-count-assert 9 + :size-assert #x70 + :flag-assert #x900000070 + ) + +(defmethod inspect mouse-info ((obj mouse-info)) + (when (not obj) + (return obj) + ) + (format #t "[~8x] ~A~%" obj (-> obj type)) + (format #t "~1Tactive: ~A~%" (-> obj active)) + (format #t "~1Tcursor: ~A~%" (-> obj cursor)) + (format #t "~1Tvalid: ~A~%" (-> obj valid)) + (format #t "~1Tid: ~D~%" (-> obj id)) + (format #t "~1Tstatus: #x~X~%" (-> obj status)) + (format #t "~1Tbutton0: #x~X~%" (-> obj button0)) + (format #t "~1Tdeltax: ~D~%" (-> obj deltax)) + (format #t "~1Tdeltay: ~D~%" (-> obj deltay)) + (format #t "~1Twheel: ~D~%" (-> obj wheel)) + (format #t "~1Tchange-time: ~D~%" (-> obj change-time)) + (format #t "~1Tbutton0-abs[3] @ #x~X~%" (-> obj button0-abs)) + (format #t "~1Tbutton0-shadow-abs[1] @ #x~X~%" (-> obj button0-shadow-abs)) + (format #t "~1Tbutton0-rel[3] @ #x~X~%" (-> obj button0-rel)) + (format #t "~1Tpos[2] @ #x~X~%" (-> obj pos)) + (dotimes (s5-0 2) + (format #t "~T [~D]~1Tpos: ~`vector`P~%" s5-0 (-> obj pos s5-0)) + ) + (format #t "~1Tposx: ~f~%" (-> obj posx)) + (format #t "~1Tposy: ~f~%" (-> obj posy)) + (format #t "~1Toldposx: ~f~%" (-> obj oldposx)) + (format #t "~1Toldposy: ~f~%" (-> obj oldposy)) + (format #t "~1Tspeedx: ~f~%" (-> obj speedx)) + (format #t "~1Tspeedy: ~f~%" (-> obj speedy)) + obj + ) + +(defmethod new mouse-info ((allocation symbol) (type-to-make type)) + (let ((v0-0 (object-new allocation type-to-make (the-as int (-> type-to-make size))))) + (set! (-> v0-0 active) #f) + (set! (-> v0-0 valid) #f) + (set! (-> v0-0 cursor) #f) + v0-0 + ) + ) + +(define *mouse* (new 'global 'mouse-info)) + +(defun service-mouse () + (let ((gp-0 *mouse*)) + (mouse-get-data gp-0) + (set! (-> gp-0 pos 1 quad) (-> gp-0 pos 0 quad)) + (set! (-> gp-0 button0-abs 2) (-> gp-0 button0-abs 1)) + (set! (-> gp-0 button0-abs 1) (-> gp-0 button0-shadow-abs 0)) + (set! (-> gp-0 button0-rel 2) (-> gp-0 button0-rel 1)) + (set! (-> gp-0 button0-rel 1) (-> gp-0 button0-rel 0)) + (set! (-> gp-0 button0-rel 0) (the-as uint 0)) + (set! (-> gp-0 speedx) 0.0) + (set! (-> gp-0 speedy) 0.0) + (cond + ((or (not (-> gp-0 valid)) (not (-> gp-0 active))) + (set! (-> gp-0 valid) #f) + (set! (-> gp-0 status) (the-as uint 0)) + (set! (-> gp-0 pos 0 quad) (the-as uint128 0)) + (set! (-> gp-0 pos 1 quad) (the-as uint128 0)) + ) + ((logtest? (-> gp-0 status) 1) + (set! (-> gp-0 change-time) (get-current-time)) + (set! (-> gp-0 speedx) (* (sign (the float (-> gp-0 deltax))) (pow (fabs (the float (-> gp-0 deltax))) 1.3))) + (set! (-> gp-0 speedy) (* (sign (the float (-> gp-0 deltay))) (pow (fabs (the float (-> gp-0 deltay))) 1.3))) + (set! (-> gp-0 posx) (fmax -256.0 (fmin 256.0 (+ (-> gp-0 posx) (-> gp-0 speedx))))) + (set! (-> gp-0 posy) (fmax -208.0 (fmin 208.0 (+ (-> gp-0 posy) (-> gp-0 speedy))))) + (let ((v1-22 (-> gp-0 button0))) + (set! (-> gp-0 button0-shadow-abs 0) v1-22) + (set! (-> gp-0 button0-abs 0) v1-22) + ) + (set! (-> gp-0 button0-rel 0) (logclear (-> gp-0 button0-abs 0) (-> gp-0 button0-abs 1))) + ) + ) + (if (and (-> gp-0 active) (-> gp-0 valid) (-> gp-0 cursor)) + (add-debug-cursor + #t + (bucket-id debug) + (+ (the int (-> gp-0 posx)) 256) + (+ (the int (-> gp-0 posy)) 208) + (the-as int (-> gp-0 button0-abs 0)) + ) + ) + ) + (none) + ) + +(defmacro cpad-pressed (pad-idx) + `(-> *cpad-list* cpads ,pad-idx button0-rel 0) + ) + +(defmacro cpad-hold (pad-idx) + `(-> *cpad-list* cpads ,pad-idx button0-abs 0) + ) + +(defmacro cpad-pressed? (pad-idx &rest buttons) + `(logtest? (cpad-pressed ,pad-idx) (pad-buttons ,@buttons)) + ) + +(defmacro cpad-hold? (pad-idx &rest buttons) + `(logtest? (cpad-hold ,pad-idx) (pad-buttons ,@buttons)) + ) + +(defmacro cpad-clear! (pad-idx &rest buttons) + `(begin + (logclear! (cpad-pressed ,pad-idx) (pad-buttons ,@buttons)) + (logclear! (cpad-hold ,pad-idx) (pad-buttons ,@buttons)) + ) + ) + +(defmacro cpad-change-time (pad-idx) + `(-> *cpad-list* cpads ,pad-idx change-time) + ) + +(defmacro check-cheat-code (cheat-var pad-idx buttons &rest body) + "execute body when a cheat code made up of sequential inputs has been inputted" + + `(when (nonzero? (cpad-pressed ,pad-idx)) ;; only check when some button has been pressed + (case ,cheat-var + ,@(apply-i + (lambda (x i) + `((,i) + (if (cpad-pressed? ,pad-idx ,x) + ,(if (< i (- (length buttons) 1)) + `(1+! ,cheat-var) + + `(begin ,@body (set! ,cheat-var 0)) + ) + + (set! ,cheat-var 0) + ) + ) + ) + buttons) + ) + ) + ) + +(defmacro cheats-sound-play (cheat?) + "play the appropriate sound for inputting a cheat code" + + `(if ,cheat? + (sound-play "select-menu") + (sound-play "cursor-options") + ) + ) diff --git a/goal_src/jak2/engine/ps2/timer-h.gc b/goal_src/jak2/engine/ps2/timer-h.gc index b4c081fe90..ad4c2b2b5c 100644 --- a/goal_src/jak2/engine/ps2/timer-h.gc +++ b/goal_src/jak2/engine/ps2/timer-h.gc @@ -5,6 +5,16 @@ ;; name in dgo: timer-h ;; dgos: ENGINE, GAME +;; There are two sources for timing: +;; - EE TIMER1, used for the frame profiler. There are 9765 counts of this per frame. It gets reset in drawable. +;; - The "stopwatch" system, used for reading the CPU clock cycle counter, at 300 MHz (32-bit) + +;; The Emotion Engine has 4 hardware timers, timer1 is used as the +(defconstant TIMER0_BANK #x10000000) ;; has HOLD register! +(defconstant TIMER1_BANK #x10000800) ;; has HOLD register! +(defconstant TIMER2_BANK #x10001000) ;; does NOT have HOLD register! +(defconstant TIMER3_BANK #x10001800) ;; does NOT have HOLD register! + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; PC Port Timer ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; diff --git a/goal_src/jak2/engine/ps2/timer.gc b/goal_src/jak2/engine/ps2/timer.gc index 67bb2d50cf..95ffa3a917 100644 --- a/goal_src/jak2/engine/ps2/timer.gc +++ b/goal_src/jak2/engine/ps2/timer.gc @@ -5,3 +5,267 @@ ;; name in dgo: timer ;; dgos: ENGINE, GAME +(defun timer-count ((timer timer-bank)) + "Return a timer's counter value" + (#when PC_PORT + (when (= timer TIMER1_BANK) + (return (- (get-bus-clock/256) *timer-reset-value*)) + ) + (format 0 "Unknown timer #x~X requested.~%" timer) + ) + + (.sync.l) + (let ((count (-> timer count))) + (.sync.l) + count + ) + ) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Interrupt Control +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; cop0 status register "interrupt enable" flag +;; if cop0 status is needed anywhere else, move this elsewhere +(defconstant COP0_STATUS_IE (the-as uint #x1)) + +(defun disable-irq () + "Disable all interrupts. Has no effect on PC Port" + (rlet ((status :class gpr :type uint)) + (let ((status-mask (lognot COP0_STATUS_IE))) + (.mfc0 status Status) + (logand! status status-mask) ;; should status-mask be replaced directly? + (.mtc0 Status status) + (.sync.p) + ) + ) + ) + +(defun enable-irq () + "Enable all interrupts. Has no effect on PC Port." + (rlet ((status :class gpr :type uint)) + (.mfc0 status Status) + (logior! status COP0_STATUS_IE) + (.mtc0 Status status) + (.sync.p) + ) + ) + +(defun stopwatch-init ((obj stopwatch)) + "Init a stopwatch" + (set! (-> obj begin-level) 0) + (set! (-> obj prev-time-elapsed) 0) + ) + + +(defun stopwatch-reset ((obj stopwatch)) + "Restart a stopwatch's times" + (set! (-> obj prev-time-elapsed) 0) + (when (> (-> obj begin-level) 0) + (let ((count 0)) + (.mfc0 count Count) + (#when PC_PORT + (set! count (the int (get-cpu-clock))) + ) + (set! (-> obj start-time) count) + ) + ) + ) + +(defun stopwatch-start ((obj stopwatch)) + "Start a stopwatch from scratch" + (when (zero? (-> obj begin-level)) + (set! (-> obj begin-level) 1) + (let ((count 0)) + (.mfc0 count Count) + (#when PC_PORT + (set! count (the int (get-cpu-clock))) + ) + (set! (-> obj start-time) count) + ) + ) + ) + +(defun stopwatch-stop ((obj stopwatch)) + "Fully stop a stopwatch and save its elapsed time" + (when (> (-> obj begin-level) 0) + (set! (-> obj begin-level) 0) + (let ((count 0)) + (let ((count 0)) + (.mfc0 count Count) ;; wrong register? a typo in a rlet? who knows. + (#when PC_PORT + (set! count (the int (get-cpu-clock))) + ) + (+! (-> obj prev-time-elapsed) (- count (-> obj start-time))) + ) + ) + ) + (none) + ) + +(defun stopwatch-begin ((obj stopwatch)) + "Begin a stopwatch level, and starts it if it hasn't yet" + (when (zero? (-> obj begin-level)) + (let ((count 0)) + (.mfc0 count Count) + (#when PC_PORT + (set! count (the int (get-cpu-clock))) + ) + (set! (-> obj start-time) count) + ) + ) + (+! (-> obj begin-level) 1) + ) + +(defun stopwatch-end ((obj stopwatch)) + "End a stopwatch level. Stops the stopwatch if it's back to level zero. + There is no guard against ending a stopwatch too many times, and a negative level + will cause errors!" + (+! (-> obj begin-level) -1) + (when (zero? (-> obj begin-level)) + (set! (-> obj begin-level) 0) + (let ((count 0)) + (.mfc0 count Count) + (#when PC_PORT + (set! count (the int (get-cpu-clock))) + ) + + (+! (-> obj prev-time-elapsed) (- count (-> obj start-time))) + ) + ) + (none) + ) + +(defun stopwatch-elapsed-ticks ((obj stopwatch)) + "Returns the elapsed time so far (in clock cycles) of a stopwatch" + (let ((elapsed (-> obj prev-time-elapsed))) + (when (> (-> obj begin-level) 0) + (let ((count 0)) + (.mfc0 count Count) + (#when PC_PORT + (set! count (the int (get-cpu-clock))) + ) + + (+! elapsed (- count (-> obj start-time))) + (set! count elapsed) ;; ?? + ) + ) + elapsed + ) + ) + +(defglobalconstant EE_SECONDS_PER_TICK (/ 1.0 3000000)) ;; 300MHz is a "decent enough" estimate +(defmacro cpu-ticks-to-seconds (ticks) + `(* ,EE_SECONDS_PER_TICK ,ticks) + ) +(defun stopwatch-elapsed-seconds ((obj stopwatch)) + "Returns the elapsed time so far (in seconds) of a stopwatch" + (cpu-ticks-to-seconds (stopwatch-elapsed-ticks obj)) + ) + + +(defmethod update-rates! clock ((obj clock) (arg0 float)) + "Set the clock ratio and recompute the rates." + ;; remember the clock-ratio + (set! (-> obj clock-ratio) arg0) + + ;; first, figure out ticks / renderered frame + (let ((f0-6 (if (nonzero? *display*) + ;; ticks per frame, no lag * how much lag * our ratio + (* (-> *display* time-factor) (-> *display* dog-ratio) arg0) + (* 5.0 arg0) + ) + ) + ) + ;; want a time-adjust-ratio of 1.0 on NTSC, at 60fps (should be 5 ticks/frame) + (set! (-> obj time-adjust-ratio) (* 0.2 f0-6)) + ) + + ;; time-adjust-ratio of 1 works out to 60 fps: + (set! (-> obj seconds-per-frame) (* 0.016666668 (-> obj time-adjust-ratio))) + (set! (-> obj frames-per-second) (if (= (-> obj time-adjust-ratio) 0.0) + 0.0 + (* 60.0 (/ 1.0 (-> obj time-adjust-ratio))) + ) + + + ) + ;; weird sparticle stuff. + (let* ((v1-12 (- (-> obj frame-counter) (-> obj old-frame-counter))) + (f0-14 v1-12) + (f1-9 (* 0.2 (the float v1-12))) + ) + (set-vector! (-> obj sparticle-data) (the-as float f0-14) (* 5.0 f1-9) f1-9 f1-9) + ) + arg0 + ) + +(defmethod advance-by! clock ((obj clock) (arg0 float)) + "Advance time by the given amount (time-frame units)" + ;; unused + (the int (+ arg0 (-> obj accum))) + + ;; add the time + (+! (-> obj integral-accum) arg0) + ;; remember the old frame-counter + (set! (-> obj old-integral-frame-counter) (-> obj integral-frame-counter)) + + ;; count "frames" (really vsyncs) + (while (>= (-> obj integral-accum) (-> *display* time-factor)) + (+! (-> obj integral-frame-counter) 1) + (set! (-> obj integral-accum) (- (-> obj integral-accum) (-> *display* time-factor))) + ) + + ;; count time frames + (let ((v1-7 (the int (+ arg0 (-> obj accum))))) + (set! (-> obj accum) (- (+ arg0 (-> obj accum)) (the float v1-7))) + (set! (-> obj old-frame-counter) (-> obj frame-counter)) + (+! (-> obj frame-counter) v1-7) + ) + + ;; update rates each time - this will compensate for lag, so we have to do it each time. + (update-rates! obj (-> obj clock-ratio)) + obj + ) + +(defmethod tick! clock ((obj clock)) + "Per-frame update function for a clock" + (if (zero? (logand (-> obj mask) (-> *kernel-context* prevent-from-run))) + (advance-by! obj (* (-> *display* time-factor) (-> *display* dog-ratio) (-> obj clock-ratio))) + (set! (-> obj sparticle-data x) 0.0) + ) + obj + ) + +(defmethod reset! clock ((obj clock)) + "Reset a clock to defaults." + (set! (-> obj frame-counter) (seconds 1000)) + (set! (-> obj integral-frame-counter) (the-as uint #x493e0)) + (set! (-> obj accum) 0.0) + (set! (-> obj old-frame-counter) (+ (-> obj frame-counter) -1)) + (set! (-> obj old-integral-frame-counter) (+ (-> obj integral-frame-counter) -1)) + (update-rates! obj 1.0) + (none) + ) + +(defmethod save! clock ((obj clock) (arg0 (pointer uint64))) + "Save clock state, return number of bytes used (16)" + (set! (-> arg0 0) (the-as uint (-> obj frame-counter))) + (set! (-> arg0 1) (-> obj integral-frame-counter)) + 16 + ) + +(defmethod load! clock ((obj clock) (arg0 (pointer uint64))) + "Load clock state, return number of bytes used (16)" + (set! (-> obj frame-counter) (the-as time-frame (-> arg0 0))) + (set! (-> obj integral-frame-counter) (-> arg0 1)) + (set! (-> obj accum) 0.0) + (set! (-> obj integral-accum) 0.0) + (set! (-> obj old-frame-counter) (-> obj frame-counter)) + (set! (-> obj old-integral-frame-counter) (-> obj integral-frame-counter)) + 16 + ) + + + + diff --git a/goal_src/jak2/engine/ps2/vif-h.gc b/goal_src/jak2/engine/ps2/vif-h.gc index 922bcfad23..b36dde7320 100644 --- a/goal_src/jak2/engine/ps2/vif-h.gc +++ b/goal_src/jak2/engine/ps2/vif-h.gc @@ -5,3 +5,74 @@ ;; name in dgo: vif-h ;; dgos: ENGINE, GAME +;;-*-Lisp-*- +(in-package goal) + +(deftype vif-stat (uint32) + ((vps uint8 :offset 0 :size 2) + (vew uint8 :offset 2 :size 1) + (mrk uint8 :offset 6 :size 1) + (vss uint8 :offset 8 :size 1) + (vfs uint8 :offset 9 :size 1) + (vis uint8 :offset 10 :size 1) + (int uint8 :offset 11 :size 1) + (er0 uint8 :offset 12 :size 1) + (er1 uint8 :offset 13 :size 1) + (fqc uint8 :offset 24 :size 4) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + + +(deftype vif-fbrst (uint32) + ((rst uint8 :offset 0 :size 1) + (fbk uint8 :offset 1 :size 1) + (stp uint8 :offset 2 :size 1) + (stc uint8 :offset 3 :size 1) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype vif-err (uint32) + ((mii uint8 :offset 0 :size 1) + (me0 uint8 :offset 1 :size 1) + (me1 uint8 :offset 2 :size 1) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype vif-bank (structure) + ((stat uint32 :offset-assert 0) + (fbrst uint32 :offset 16) + (err vif-err :offset 32) + (mark uint32 :offset 48) + (cycle uint32 :offset 64) + (mode uint32 :offset 80) + (num uint32 :offset 96) + (mask uint32 :offset 112) + (code uint32 :offset 128) + (itops uint32 :offset 144) + (base uint32 :offset 160) + (offset uint32 :offset 176) + (tops uint32 :offset 192) + (itop uint32 :offset 208) + (top uint32 :offset 224) + (r0 uint32 :offset 256) + (r1 uint32 :offset 272) + (r2 uint32 :offset 288) + (r3 uint32 :offset 304) + (c0 uint32 :offset 320) + (c1 uint32 :offset 336) + (c2 uint32 :offset 352) + (c3 uint32 :offset 368) + ) + :method-count-assert 9 + :size-assert #x174 + :flag-assert #x900000174 + ) diff --git a/goal_src/jak2/engine/ps2/vu1-macros.gc b/goal_src/jak2/engine/ps2/vu1-macros.gc index 782904a2b3..59dbfa1c64 100644 --- a/goal_src/jak2/engine/ps2/vu1-macros.gc +++ b/goal_src/jak2/engine/ps2/vu1-macros.gc @@ -5,3 +5,234 @@ ;; name in dgo: vu1-macros ;; dgos: ENGINE, GAME + +(defmacro vu-clip (vfr cf) + "Returns the result of VCLIP. + NOTE: this implementation is pretty inefficient. + If this ends up used a lot, it's probably worth rewriting. + " + `(let ((vec (new 'stack 'vector)) + (flag ,cf) + ) + (.svf vec ,vfr) + (let* ((w-plus (fabs (-> vec w))) + (w-minus (- 0.0 w-plus)) + ) + ;; CF = CF << 6 + (set! flag (logand #xffffff (shl flag 6))) + + (when (> (-> vec x) w-plus) + (logior! flag 1) + ) + (when (< (-> vec x) w-minus) + (logior! flag 2) + ) + (when (> (-> vec y) w-plus) + (logior! flag 4) + ) + (when (< (-> vec y) w-minus) + (logior! flag 8) + ) + (when (> (-> vec z) w-plus) + (logior! flag 16) + ) + (when (< (-> vec z) w-minus) + (logior! flag 32) + ) + ) + flag + ) + ) + + +(defmacro vftoi4.xyzw (dst src) + "convert to 28.4 integer. This does the multiply while the number is still + a float. This will have issues for very large floats, but it seems like this + is how PCSX2 does it as well, so maybe it's right? + NOTE: this is the only version of the instruction used in Jak 1, so we + don't need to worry about masks." + + `(begin + (rlet ((temp :class vf)) + (set! temp 16.0) + (.mul.x.vf temp ,src temp) + (.ftoi.vf ,dst temp) + ) + ) + ) + +(defmacro vftoi12.xyzw (dst src) + "convert to 20.12 integer. This does the multiply while the number is still + a float. This will have issues for very large floats, but it seems like this + is how PCSX2 does it as well, so maybe it's right? + NOTE: this is the only version of the instruction used in Jak 1, so we + don't need to worry about masks." + + `(begin + (rlet ((temp :class vf)) + (set! temp 4096.0) + (.mul.x.vf temp ,src temp) + (.ftoi.vf ,dst temp) + ) + ) + ) + +(defmacro vftoi15.xyzw (dst src) + "convert to 17.15 integer. This does the multiply while the number is still + a float. This will have issues for very large floats, but it seems like this + is how PCSX2 does it as well, so maybe it's right? + NOTE: this is the only version of the instruction used in Jak 1, so we + don't need to worry about masks." + + `(begin + (rlet ((temp :class vf)) + (set! temp 32768.0) + (.mul.x.vf temp ,src temp) + (.ftoi.vf ,dst temp) + ) + ) + ) + +(defmacro vitof4.xyzw (dst src) + "convert from a 28.4 integer. This does the multiply while the number is still + a float. This will have issues for very large floats, but it seems like this + is how PCSX2 does it as well, so maybe it's right? + NOTE: this is the only version of the instruction used in Jak 1, so we + don't need to worry about masks." + + `(begin + (rlet ((temp :class vf)) + (.itof.vf ,dst ,src) + (set! temp 0.0625) + (.mul.x.vf ,dst ,dst temp) + ) + ) + ) + +(defmacro vitof12.xyzw (dst src) + "convert from a 20.12 integer. This does the multiply while the number is still + a float. This will have issues for very large floats, but it seems like this + is how PCSX2 does it as well, so maybe it's right? + NOTE: this is the only version of the instruction used in Jak 1, so we + don't need to worry about masks." + +`(begin + (rlet ((temp :class vf)) + (.itof.vf ,dst ,src) + (set! temp 0.000244140625) + (.mul.x.vf ,dst ,dst temp) + ) + ) +) + +(defmacro vitof15.xyzw (dst src) + "convert from a 17.15 integer. This does the multiply while the number is still + a float. This will have issues for very large floats, but it seems like this + is how PCSX2 does it as well, so maybe it's right? + NOTE: this is the only version of the instruction used in Jak 1, so we + don't need to worry about masks." + +`(begin + (rlet ((temp :class vf)) + (.itof.vf ,dst ,src) + (set! temp 0.000030517578125) + (.mul.x.vf ,dst ,dst temp) + ) + ) +) + +;; In the original game, init-for-transform stashed a bunch of stuff in registers, to be used by other functions. +;; In OpenGOAL, this seems risky so we're going to back up this manually. +;; This does mean this file now has code, but it's not a big deal. +;; This seems like it is very old GOAL code and is really only used for debug and a few weird leftovers. +(deftype transform-regs (structure) + ;; Eventually we might want to actually name some of these fields to be more comprehensible? + (;; vf0 not included! + (vf1 uint128) + (vf2 uint128) + (vf3 uint128) + (vf4 uint128) + (vf5 uint128) + (vf6 uint128) + (vf7 uint128) + (vf8 uint128) + (vf9 uint128) + (vf10 uint128) + (vf11 uint128) + (vf12 uint128) + (vf13 uint128) + (vf14 uint128) + (vf15 uint128) + (vf16 uint128) + (vf17 uint128) + (vf18 uint128) + (vf19 uint128) + (vf20 uint128) + (vf21 uint128) + (vf22 uint128) + (vf23 uint128) + (vf24 uint128) + (vf25 uint128) + (vf26 uint128) + (vf27 uint128) + (vf28 uint128) + (vf29 uint128) + (vf30 uint128) + (vf31 uint128) + ) + ) + +(define *transform-regs* (new 'static 'transform-regs)) + + +(defmacro with-vf0 (&rest body) + "Macro for using the ps2-style vf0 register." + + `(rlet ((vf0 :class vf)) + (init-vf0-vector) + ,@body + ) + ) + +(defmacro load-vf (reg) + "Load a vf from the preserved vf registers" + `(.lvf ,reg (&-> *transform-regs* ,reg)) + ) + +(defmacro save-vf (reg) + "Save a vf to the preserved vf registers" + `(.svf (&-> *transform-regs* ,reg) ,reg) + ) + +(defmacro with-vf (regs &key (rw 'read) &rest body) + "Macro for using the specified ps2-style vf registers. These are preserved in *transform-regs* + Each register name in regs must be a valid vf register name. vf0 CANNOT be used! Use with-vf0 for that instead. + rw specifies the read/write mode: + 'read means the registers will be read from the preserved registers. This is the default + 'write means the registers will be written to the preserved registers at the end + 'readwrite (or 'rw) means both + #f means neither, turning this into a fancy macro around rlet." + + `(rlet (,@(apply (lambda (x) `(,x :class vf)) regs)) + + ,@(if (or (eq? rw ''read) (eq? rw ''readwrite) (eq? rw ''rw)) + (apply (lambda (y) + `(load-vf ,y) + ) regs) + '() + ) + + ,@body + + ;; this will mess up the return value! + ,@(if (or (eq? rw ''write) (eq? rw ''readwrite) (eq? rw ''rw)) + (apply (lambda (y) + `(save-vf ,y) + ) regs) + '() + ) + + ) + ) + + diff --git a/goal_src/jak2/engine/sound/gsound-h.gc b/goal_src/jak2/engine/sound/gsound-h.gc index ad4472357c..1925775d8e 100644 --- a/goal_src/jak2/engine/sound/gsound-h.gc +++ b/goal_src/jak2/engine/sound/gsound-h.gc @@ -5,3 +5,425 @@ ;; name in dgo: gsound-h ;; dgos: ENGINE, GAME +(defenum sound-command + :type uint16 + ; (load-bank) + ; (load-music) + ; (unload-bank) + ; (play) + ; (pause-sound) + ; (stop-sound) + ; (continue-sound) + ; (set-param) + ; (set-master-volume) + ; (pause-group) + ; (stop-group) + ; (continue-group) + ; (get-irx-version) + ; (set-falloff-curve) + ; (set-sound-falloff) + ; (reload-info) + ; (set-language) + ; (set-flava) + ; (set-reverb) + ; (set-ear-trans) + ; (shutdown) + ; (list-sounds) + ; (unload-music) + ; (set-fps) + ) + +(defenum sound-group + :bitfield #t + :type uint8 + ; (sfx) + ; (music) + ; (dialog) + ; (sog3) + ; (ambient) + ; (sog5) + ; (sog6) + ; (sog7) + ) + +(defenum sound-mask + :bitfield #t + :type uint16 + ; (volume) + ; (pitch) + ; (bend) + ; (unused) + ; (time) + ; (trans) + ; (fo-min) + ; (fo-max) + ; (fo-curve) + ) + +(deftype sound-stream-name (structure) + ((name uint8 48 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype sound-id (uint32) + () + :method-count-assert 10 + :size-assert #x4 + :flag-assert #xa00000004 + (:methods + (unused-9 () none 9) + ) + ) + +(deftype sound-bank-id (uint32) + () + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype sound-name (uint128) + ((lo uint64 :offset 0 :size 64) + (hi uint64 :offset 64 :size 64) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +;; definition of type sound-rpc-cmd +(deftype sound-rpc-cmd (structure) + ((rsvd1 uint16 :offset-assert 0) + (command sound-command :offset-assert 2) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype sound-play-params (structure) + ((mask uint16 :offset-assert 0) + (pitch-mod int16 :offset-assert 2) + (bend int16 :offset-assert 4) + (fo-min int16 :offset-assert 6) + (fo-max int16 :offset-assert 8) + (fo-curve int8 :offset-assert 10) + (priority int8 :offset-assert 11) + (volume int32 :offset-assert 12) + (trans int32 3 :offset-assert 16) + (group uint8 :offset-assert 28) + (reg uint8 3 :offset-assert 29) + ) + :allow-misaligned + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(deftype sound-rpc-bank-cmd (sound-rpc-cmd) + ((bank-name sound-name :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(deftype sound-rpc-test-cmd (sound-rpc-cmd) + ((ee-addr uint32 :offset-assert 4) + (param0 uint16 :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xa + :flag-assert #x90000000a + ) + +(deftype sound-rpc-sound-cmd (sound-rpc-cmd) + ((id sound-id :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype sound-rpc-group-cmd (sound-rpc-cmd) + ((group sound-group :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x5 + :flag-assert #x900000005 + ) + +(deftype sound-rpc-load-bank (sound-rpc-bank-cmd) + ((ee-addr uint32 :offset-assert 32) + ) + :method-count-assert 9 + :size-assert #x24 + :flag-assert #x900000024 + ) + +(deftype sound-rpc-load-music (sound-rpc-bank-cmd) + () + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(deftype sound-rpc-unload-bank (sound-rpc-bank-cmd) + () + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(deftype sound-rpc-play (sound-rpc-sound-cmd) + ((name sound-name :offset-assert 16) + (params sound-play-params :inline :offset-assert 32) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + +(deftype sound-rpc-pause-sound (sound-rpc-sound-cmd) + () + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype sound-rpc-stop-sound (sound-rpc-sound-cmd) + () + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype sound-rpc-continue-sound (sound-rpc-sound-cmd) + () + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype sound-rpc-set-param (sound-rpc-sound-cmd) + ((params sound-play-params :inline :offset-assert 8) + (auto-time int32 :offset-assert 40) + (auto-from int32 :offset-assert 44) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype sound-rpc-set-master-volume (sound-rpc-group-cmd) + ((volume int32 :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +(deftype sound-rpc-pause-group (sound-rpc-group-cmd) + () + :method-count-assert 9 + :size-assert #x5 + :flag-assert #x900000005 + ) + +(deftype sound-rpc-stop-group (sound-rpc-group-cmd) + () + :method-count-assert 9 + :size-assert #x5 + :flag-assert #x900000005 + ) + +(deftype sound-rpc-continue-group (sound-rpc-group-cmd) + () + :method-count-assert 9 + :size-assert #x5 + :flag-assert #x900000005 + ) + +(deftype sound-rpc-get-irx-version (sound-rpc-cmd) + ((major uint32 :offset-assert 4) + (minor uint32 :offset-assert 8) + (ee-addr pointer :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype sound-rpc-set-language (sound-rpc-cmd) + ((lang uint32 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype sound-rpc-set-stereo-mode (sound-rpc-cmd) + ((mode int32 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype sound-rpc-set-reverb (sound-rpc-cmd) + ((core uint8 :offset-assert 4) + (reverb int32 :offset-assert 8) + (left uint32 :offset-assert 12) + (right uint32 :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + ) + +(deftype sound-rpc-set-ear-trans (sound-rpc-cmd) + ((ear-trans1 int32 3 :offset-assert 4) + (ear-trans0 int32 3 :offset-assert 16) + (cam-trans int32 3 :offset-assert 28) + (cam-angle int32 :offset-assert 40) + ) + :method-count-assert 9 + :size-assert #x2c + :flag-assert #x90000002c + ) + +(deftype sound-rpc-set-flava (sound-rpc-cmd) + ((flava uint8 :offset-assert 4) + (excitement uint8 :offset-assert 5) + ) + :method-count-assert 9 + :size-assert #x6 + :flag-assert #x900000006 + ) + +(deftype sound-rpc-set-midi-reg (sound-rpc-cmd) + ((reg int32 :offset-assert 4) + (value int16 :offset-assert 8) + ) + :method-count-assert 9 + :size-assert #xa + :flag-assert #x90000000a + ) + +(deftype sound-rpc-shutdown (sound-rpc-cmd) + () + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype sound-rpc-set-fps (sound-rpc-cmd) + ((fps uint8 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x5 + :flag-assert #x900000005 + ) + +(deftype sound-rpc-list-sounds (sound-rpc-cmd) + () + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype sound-rpc-unload-music (sound-rpc-cmd) + () + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype sound-rpc-union (structure) + ((data uint32 20 :offset-assert 0) + (load-bank sound-rpc-load-bank :offset 0) + (unload-bank sound-rpc-unload-bank :offset 0) + (play sound-rpc-play :offset 0) + (pause-sound sound-rpc-pause-sound :offset 0) + (stop-sound sound-rpc-stop-sound :offset 0) + (continue-sound sound-rpc-continue-sound :offset 0) + (set-param sound-rpc-set-param :offset 0) + (set-master-volume sound-rpc-set-master-volume :offset 0) + (pause-group sound-rpc-pause-group :offset 0) + (stop-group sound-rpc-stop-group :offset 0) + (continue-group sound-rpc-continue-group :offset 0) + (get-irx-version sound-rpc-get-irx-version :offset 0) + (set-language sound-rpc-set-language :offset 0) + (set-reverb sound-rpc-set-reverb :offset 0) + (set-ear-trans sound-rpc-set-ear-trans :offset 0) + (set-flava sound-rpc-set-flava :offset 0) + (set-midi-reg sound-rpc-set-midi-reg :offset 0) + (set-fps sound-rpc-set-fps :offset 0) + (shutdown sound-rpc-shutdown :offset 0) + (list-sounds sound-rpc-list-sounds :offset 0) + (unload-music sound-rpc-unload-music :offset 0) + ) + :method-count-assert 9 + :size-assert #x50 + :flag-assert #x900000050 + ) + +(deftype sound-spec (basic) + ((mask sound-mask :offset-assert 4) + (num float :offset-assert 8) + (group sound-group :offset-assert 12) + (reg uint8 3 :offset-assert 13) + (sound-name-char uint8 16 :offset-assert 16) + (sound-name sound-name :offset 16) + (trans int32 4 :offset-assert 32) + (volume int32 :offset-assert 48) + (pitch-mod int32 :offset-assert 52) + (bend int32 :offset-assert 56) + (fo-min int16 :offset-assert 60) + (fo-max int16 :offset-assert 62) + (fo-curve int8 :offset-assert 64) + (priority int8 :offset-assert 65) + (auto-time int32 :offset-assert 68) + (auto-from int32 :offset-assert 72) + ) + :method-count-assert 9 + :size-assert #x4c + :flag-assert #x90000004c + ) + +(define *current-sound-id* (the-as sound-id #x10000)) + +(deftype ambient-sound (basic) + ((spec sound-spec :offset-assert 4) + (playing-id sound-id :offset-assert 8) + (trans vector :inline :offset-assert 16) + (name sound-name :offset-assert 32) + (play-time time-frame :offset-assert 48) + (time-base time-frame :offset-assert 56) + (time-random time-frame :offset-assert 64) + (volume int32 :offset-assert 72) + (pitch int32 :offset-assert 76) + (falloff-near int32 :offset-assert 80) + (falloff-far int32 :offset-assert 84) + (falloff-mode int32 :offset-assert 88) + (params (pointer float) :offset-assert 92) + (param-count int32 :offset-assert 96) + (entity entity :offset-assert 100) + (sound-count int32 :offset-assert 104) + ) + :method-count-assert 16 + :size-assert #x6c + :flag-assert #x100000006c + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + (dummy-13 () none 13) + (dummy-14 () none 14) + (dummy-15 () none 15) + ) + ) diff --git a/goal_src/jak2/engine/util/capture-h.gc b/goal_src/jak2/engine/util/capture-h.gc index f575a4cc0d..7dfbfd3eb7 100644 --- a/goal_src/jak2/engine/util/capture-h.gc +++ b/goal_src/jak2/engine/util/capture-h.gc @@ -5,3 +5,50 @@ ;; name in dgo: capture-h ;; dgos: ENGINE, GAME +(declare-file (debug)) +(when *debug-segment* + +(deftype gs-store-image-packet (structure) + ((vifcode vif-tag 4 :offset-assert 0) + (giftag gif-tag :offset-assert 16) + (bitbltbuf gs-bitbltbuf :offset-assert 32) + (bitbltbuf-addr gs-reg64 :offset-assert 40) + (trxpos gs-trxpos :offset-assert 48) + (trxpos-addr gs-reg64 :offset-assert 56) + (trxreg gs-trxreg :offset-assert 64) + (trxreg-addr gs-reg64 :offset-assert 72) + (finish int64 :offset-assert 80) + (finish-addr gs-reg64 :offset-assert 88) + (trxdir gs-trxdir :offset-assert 96) + (trxdir-addr gs-reg64 :offset-assert 104) + ) + :method-count-assert 9 + :size-assert #x70 + :flag-assert #x900000070 + ) + +(deftype screen-shot-work (structure) + ((count int16 :offset-assert 0) + (size int16 :offset-assert 2) + (name basic :offset-assert 4) + (highres-enable basic :offset-assert 8) + (hud-enable basic :offset-assert 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(define *screen-shot-work* (new 'global 'screen-shot-work)) + +(set! (-> *screen-shot-work* count) -1) +(set! (-> *screen-shot-work* size) -1) +(set! (-> *screen-shot-work* highres-enable) #f) +(set! (-> *screen-shot-work* hud-enable) #f) +(define *image-name* (new 'global 'string 32 (the-as string #f))) + + +) + + + diff --git a/goal_src/jak2/engine/util/profile-h.gc b/goal_src/jak2/engine/util/profile-h.gc index f3f8730c0b..7ec6f7c300 100644 --- a/goal_src/jak2/engine/util/profile-h.gc +++ b/goal_src/jak2/engine/util/profile-h.gc @@ -5,3 +5,109 @@ ;; name in dgo: profile-h ;; dgos: ENGINE, GAME +(deftype profile-segment (structure) + ((name basic :offset-assert 0) + (start-time int16 :offset-assert 4) + (end-time int16 :offset-assert 6) + (count uint8 :offset-assert 8) + (vu-count uint8 :offset-assert 9) + (depth uint16 :offset-assert 10) + (color uint32 :offset-assert 12) + (code-time uint16 :offset 4) + (vu-time uint16 :offset 6) + ) + :allow-misaligned + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype profile-collapse (structure) + ((count int32 :offset-assert 0) + (data profile-segment 48 :inline :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x304 + :flag-assert #x900000304 + ) + +(deftype profile-segment-array (basic) + ((count int16 :offset-assert 4) + (depth int8 :offset-assert 6) + (max-depth int8 :offset-assert 7) + (base-time int16 :offset-assert 8) + (segment basic 9 :offset-assert 12) + (data profile-segment 512 :inline :offset-assert 48) + ) + :method-count-assert 13 + :size-assert #x2030 + :flag-assert #xd00002030 + (:methods + (get-total-time (_type_) int 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + (dummy-12 () none 12) + ) + ) + +(deftype profile-array (structure) + ((data profile-segment-array 2 :offset-assert 0) + ) + :method-count-assert 12 + :size-assert #x8 + :flag-assert #xc00000008 + (:methods + (dummy-9 () none 9) + (dummy-10 () none 10) + (dummy-11 () none 11) + ) + ) + +(defmethod get-total-time profile-segment-array ((obj profile-segment-array)) + (- (-> obj data 0 end-time) (-> obj data 0 start-time)) + ) + +(define *profile-gap-color* (new 'static 'rgba :r #x30 :g #x30 :b #x30 :a #x80)) +(define *profile-all-color* (new 'static 'rgba :r #x55 :g #x55 :b #x55 :a #x80)) +(define *profile-particles-color* (new 'static 'rgba :r #x80 :g #x40 :b #x40 :a #x80)) +(define *profile-target-color* (new 'static 'rgba :r #x40 :g #x80 :b #x40 :a #x80)) +(define *profile-target-post-color* (new 'static 'rgba :r #x40 :g #x40 :b #x80 :a #x80)) +(define *profile-joints-color* (new 'static 'rgba :r #x70 :g #x70 :b #x20 :a #x80)) +(define *profile-debug-color* (new 'static 'rgba :r #x80 :g #x80 :b #x80 :a #x80)) +(define *profile-draw-hook-color* (new 'static 'rgba :r #x20 :g #x70 :b #x70 :a #x80)) +(define *profile-sky-color* (new 'static 'rgba :r #x80 :g #x60 :b #x20 :a #x80)) +(define *profile-ocean-color* (new 'static 'rgba :r #x60 :g #x80 :b #x20 :a #x80)) +(define *profile-background-color* (new 'static 'rgba :r #x60 :g #x60 :b #x40 :a #x80)) +(define *profile-bsp-color* (new 'static 'rgba :r #x60 :g #x40 :b #x60 :a #x80)) +(define *profile-foreground-color* (new 'static 'rgba :r #x40 :g #x60 :b #x60 :a #x80)) +(define *profile-tfrag-color* (new 'static 'rgba :r #x80 :g #x80 :a #x80)) +(define *profile-instance-tie-color* (new 'static 'rgba :r #x80 :b #x80 :a #x80)) +(define *profile-instance-shrubbery-color* (new 'static 'rgba :g #x80 :b #x80 :a #x80)) +(define *profile-generic-tie-color* (new 'static 'rgba :r #x80 :g #x20 :b #x60 :a #x80)) +(define *profile-bones-color* (new 'static 'rgba :r #x20 :g #x80 :b #x60 :a #x80)) +(define *profile-generic-merc-color* (new 'static 'rgba :r #x20 :g #x60 :b #x80 :a #x80)) +(define *profile-shadow-color* (new 'static 'rgba :r #x48 :g #x48 :b #x70 :a #x80)) +(define *profile-update-actors-color* (new 'static 'rgba :r #x48 :g #x70 :b #x48 :a #x80)) +(define *profile-menu-hook-color* (new 'static 'rgba :r #x70 :g #x48 :b #x48 :a #x80)) +(define *profile-texture-color* (new 'static 'rgba :r #x80 :g #x70 :b #x10 :a #x80)) +(define *profile-effects-color* (new 'static 'rgba :r #x70 :g #x80 :b #x10 :a #x80)) +(define *profile-sprite-color* (new 'static 'rgba :r #x70 :g #x10 :b #x80 :a #x80)) +(define *profile-merc-color* (new 'static 'rgba :r #x10 :g #x70 :b #x80 :a #x80)) +(define *profile-actors-color* (new 'static 'rgba :r #x80 :g #x10 :b #x70 :a #x80)) +(define *profile-collide-color* (new 'static 'rgba :r #x80 :g #x40 :b #x80 :a #x80)) +(define *profile-nav-color* (new 'static 'rgba :r #x38 :g #x48 :b #x80 :a #x80)) +(define *profile-camera-color* (new 'static 'rgba :r #x80 :g #x80 :b #x80 :a #x80)) +(define *profile-blit-color* (new 'static 'rgba :r #xff :g #xff :b #x80 :a #x80)) +(define *profile-hud-color* (new 'static 'rgba :r #xff :g #x80 :b #xff :a #x80)) +(define *profile-emerc-color* (new 'static 'rgba :r #x80 :g #xff :b #xff :a #x80)) +(when *debug-segment* + (define *profile-array* (new 'debug 'profile-array)) + (set! (-> *profile-array* data 0) (new 'debug 'profile-segment-array)) + (set! (-> *profile-array* data 1) (new 'debug 'profile-segment-array)) + (define *profile-collapse* (new 'debug 'profile-collapse)) + (define *profile-interrupt-segment* (-> *profile-array* data 1)) + (define *profile-interrupt-start* #f) + ) + + + diff --git a/goal_src/jak2/engine/util/types-h.gc b/goal_src/jak2/engine/util/types-h.gc index 0db8bc656a..4ce700cd81 100644 --- a/goal_src/jak2/engine/util/types-h.gc +++ b/goal_src/jak2/engine/util/types-h.gc @@ -5,6 +5,18 @@ ;; name in dgo: types-h ;; dgos: ENGINE, GAME +(defenum language-enum + :type int64 + (english) + (french) + (german) + (spanish) + (italian) + (japanese) + (uk-english) + ) + + (deftype part-id (uint32) () :method-count-assert 9 diff --git a/goal_src/jak2/kernel-defs.gc b/goal_src/jak2/kernel-defs.gc index 3dea01d128..2468fa510f 100644 --- a/goal_src/jak2/kernel-defs.gc +++ b/goal_src/jak2/kernel-defs.gc @@ -90,8 +90,21 @@ (define-extern dgo-load (function string kheap link-flag int none)) (define-extern malloc (function symbol int pointer)) +(declare-type cpad-info basic) +(define-extern cpad-open (function cpad-info int cpad-info)) +(define-extern cpad-get-data (function cpad-info cpad-info)) + +(declare-type mouse-info basic) +(define-extern mouse-get-data (function mouse-info none)) +(define-extern scf-get-territory (function int)) ;; not actually a scf function... +(define-extern __read-ee-timer (function uint)) +(define-extern __mem-move (function pointer pointer uint none)) + +(define-extern file-stream-read (function file-stream pointer int int)) +(define-extern file-stream-open (function file-stream basic symbol file-stream)) +(define-extern file-stream-length (function file-stream int)) ;; PC stuff diff --git a/goal_src/jak2/kernel/gcommon.gc b/goal_src/jak2/kernel/gcommon.gc index 61bc2ad292..6da4e3b275 100644 --- a/goal_src/jak2/kernel/gcommon.gc +++ b/goal_src/jak2/kernel/gcommon.gc @@ -1189,4 +1189,58 @@ ,@body ) ) - ) \ No newline at end of file + ) + +;;;;;;;;;;;;;;;;;;;;;;;; +;; Decompiler Macros +;;;;;;;;;;;;;;;;;;;;;;;; + +;; inserted by the decompiler for assembly branches. +(defmacro b! (pred destination &key (delay '()) &key (likely-delay '())) + "Branch!" + ;; evaluate the predicate + `(let ((should-branch ,pred)) + ;; normal delay slot: + ,delay + (when should-branch + ,likely-delay + (goto ,destination) + ) + ) + ) + +;; the decompiler may fail to recognize setting fields of a 128-bit bitfield +;; and will rely on this macro: +(defmacro copy-and-set-field (original field-name field-value) + `(let ((temp-copy ,original)) + (set! (-> temp-copy ,field-name) ,field-value) + temp-copy + ) + ) + +;; inserted by the decompiler if a c->goal bool conversion can't be compacted into a single +;; expression. +(defmacro cmove-#f-zero (dest condition src) + `(if (zero? ,condition) + (set! ,dest #f) + (set! ,dest ,src) + ) + ) + +(defmacro empty-form () + `(none) + ) + +;;;;;;;;;;;;;;;;;;;;;;; +;; PC Port asm macros +;;;;;;;;;;;;;;;;;;;;;;; +(#when PC_PORT + ;; SYNC is an EE instruction that waits for various memory access and DMA to be completed + ;; DMA will be instant in the PC port, so these are no longer necessary + (fake-asm .sync.l) + (fake-asm .sync.p) + ;; Copies the contents of a cop0 (system control) register to a gpr + (fake-asm .mfc0 dest src) + ;; Copies the contents of a gpr to a cop0 (system control) register + (fake-asm .mtc0 dest src) + ) diff --git a/goal_src/jak2/kernel/gkernel-h.gc b/goal_src/jak2/kernel/gkernel-h.gc index 9d2d488d35..997847149e 100644 --- a/goal_src/jak2/kernel/gkernel-h.gc +++ b/goal_src/jak2/kernel/gkernel-h.gc @@ -169,9 +169,9 @@ :flag-assert #xf0000005c (:methods (new (symbol type int) _type_ 0) - (update-rates! (_type_ float) none 9) - (advance-by! (_type_ float) none 10) - (tick! (_type_) none 11) + (update-rates! (_type_ float) float 9) + (advance-by! (_type_ float) clock 10) + (tick! (_type_) clock 11) (save! (_type_ (pointer uint64)) int 12) (load! (_type_ (pointer uint64)) int 13) (reset! (_type_) none 14) diff --git a/goalc/compiler/compilation/Static.cpp b/goalc/compiler/compilation/Static.cpp index 379acb925e..a172284acc 100644 --- a/goalc/compiler/compilation/Static.cpp +++ b/goalc/compiler/compilation/Static.cpp @@ -847,7 +847,12 @@ void Compiler::fill_static_array_inline(const goos::Object& form, if (is_integer(content_type)) { typecheck(form, TypeSpec("integer"), sr.typespec()); } else { - typecheck(form, content_type, sr.typespec()); + if (sr.is_symbol() && sr.symbol_name() == "#f") { + // allow #f for any structure. + typecheck(form, TypeSpec("structure"), content_type); + } else { + typecheck(form, content_type, sr.typespec()); + } } if (sr.is_symbol()) { ASSERT(deref_info.stride == 4);