diff --git a/decompiler/IR2/AtomicOpTypeAnalysis.cpp b/decompiler/IR2/AtomicOpTypeAnalysis.cpp index 3cf35adaa7..e32792be86 100644 --- a/decompiler/IR2/AtomicOpTypeAnalysis.cpp +++ b/decompiler/IR2/AtomicOpTypeAnalysis.cpp @@ -190,7 +190,7 @@ TP_Type SimpleExpression::get_type(const TypeState& input, } // new for jak 2: if (env.version == GameVersion::Jak2 && in_type.is_integer_constant() && - in_type.get_integer_constant() <= UINT32_MAX) { + (s64)((s32)in_type.get_integer_constant()) == (s64)in_type.get_integer_constant()) { return TP_Type::make_from_ts("float"); } return in_type; @@ -407,6 +407,8 @@ TP_Type SimpleExpression::get_type_int2(const TypeState& input, return TP_Type::make_from_ts(TypeSpec("float")); } return TP_Type::make_from_ts(TypeSpec("int")); + } else { + return TP_Type::make_from_ts(TypeSpec("uint")); } } break; diff --git a/decompiler/IR2/FormExpressionAnalysis.cpp b/decompiler/IR2/FormExpressionAnalysis.cpp index 310e16f057..39133a1b17 100644 --- a/decompiler/IR2/FormExpressionAnalysis.cpp +++ b/decompiler/IR2/FormExpressionAnalysis.cpp @@ -694,6 +694,15 @@ void SimpleExpressionElement::update_from_stack_identity(const Env& env, } } +bool u64_valid_for_float_constant(u64 in) { + u32 top = in >> 32; + if (top == 0 || top == UINT32_MAX) { + return true; + } else { + return false; + } +} + void SimpleExpressionElement::update_from_stack_gpr_to_fpr(const Env& env, FormPool& pool, FormStack& stack, @@ -724,12 +733,10 @@ void SimpleExpressionElement::update_from_stack_gpr_to_fpr(const Env& env, auto frm = pool.alloc_sequence_form(nullptr, src_fes); if (src_fes.size() == 1) { auto int_constant = get_goal_integer_constant(frm, env); - - if (int_constant && (*int_constant <= UINT32_MAX)) { + if (int_constant && u64_valid_for_float_constant(*int_constant)) { float flt; memcpy(&flt, &int_constant.value(), sizeof(float)); - result->push_back(pool.alloc_element(flt)); return; } diff --git a/decompiler/analysis/atomic_op_builder.cpp b/decompiler/analysis/atomic_op_builder.cpp index fdf2de9c4e..435a7d182b 100644 --- a/decompiler/analysis/atomic_op_builder.cpp +++ b/decompiler/analysis/atomic_op_builder.cpp @@ -308,6 +308,7 @@ std::unique_ptr make_asm_op(const Instruction& i0, int idx) { case InstructionKind::MSUBAS: case InstructionKind::MSUBS: case InstructionKind::ADDAS: + case InstructionKind::RSQRTS: // Moves / Loads / Stores case InstructionKind::CTC2: diff --git a/decompiler/config/jak2/all-types.gc b/decompiler/config/jak2/all-types.gc index b8225091fc..8a443d9534 100644 --- a/decompiler/config/jak2/all-types.gc +++ b/decompiler/config/jak2/all-types.gc @@ -78,7 +78,7 @@ ) (deftype vector (structure) - ((data float 4 :offset-assert 0) + ((data float 4 :score -1 :offset-assert 0) (x float :offset 0) (y float :offset 4) (z float :offset 8) @@ -751,6 +751,10 @@ ;; types-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(deftype part-id (uint32) + () + :flag-assert #x900000004 + ) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; vu1-macros ;; @@ -771,7 +775,22 @@ :no-runtime-type ) -#| +(deftype float-type (uint32) + () + :flag-assert #x900000004 + :no-runtime-type + ) + +(deftype xyzw (uint128) + () + :flag-assert #x900000010 + ) + +(deftype xyzwh (uint128) + () + :flag-assert #x900000010 + ) + (deftype random-generator (basic) ((seed uint32 :offset-assert 4) ) @@ -779,48 +798,47 @@ :size-assert #x8 :flag-assert #x900000008 ) -|# -;; (define-extern truncate object) ;; (function float float) -;; (define-extern floor object) -;; (define-extern ceil object) -;; (define-extern integral? object) ;; (function float symbol) -;; (define-extern fractional-part object) ;; (function float float) -;; (define-extern sawtooth-wave object) -;; (define-extern triangle-wave object) -;; (define-extern log-x-plus-1-order9 object) -;; (define-extern logf object) -;; (define-extern log2f object) -;; (define-extern exp-slead object) ;; (pointer float) -;; (define-extern exp-strail object) ;; (pointer float) -;; (define-extern exp object) ;; (function float float) -;; (define-extern pow object) -;; (define-extern print-exp object) -;; (define-extern print-time object) -;; (define-extern log2 object) ;; (function int int) -;; (define-extern seek object) ;; (function float float float float) -;; (define-extern seek-ease object) -;; (define-extern seek-ease-in-out object) -;; (define-extern lerp object) ;; (function float float float float) -;; (define-extern lerp-scale-old object) -;; (define-extern lerp-scale object) ;; (function float float float float float float) -;; (define-extern lerp-clamp object) ;; (function float float float float) -;; (define-extern seekl object) ;; (function int int int int) -;; (define-extern rand-vu-init object) ;; (function float float) -;; (define-extern rand-vu object) ;; (function float) -;; (define-extern rand-vu-nostep object) ;; (function float) -;; (define-extern rand-vu-float-range object) ;; (function float float float) -;; (define-extern rand-vu-percent? object) ;; (function float symbol) -;; (define-extern rand-vu-int-range object) ;; (function int int int) -;; (define-extern rand-vu-int-count object) ;; (function int int) -;; (define-extern rand-vu-int-count-excluding object) -;; (define-extern rand-vu-int-range-exclude object) -;; (define-extern *random-generator* object) ;; random-generator -;; (define-extern rand-uint31-gen object) ;; (function random-generator uint) -;; (define-extern cube-root object) -;; (define-extern int-noise object) -;; (define-extern smooth-step object) -;; (define-extern smooth-interp object) +(define-extern truncate (function float float)) +(define-extern floor (function float float)) +(define-extern ceil (function float float)) +(define-extern integral? (function float symbol)) +(define-extern fractional-part (function float float)) +(define-extern sawtooth-wave (function float float)) +(define-extern triangle-wave (function float float)) +(define-extern log-x-plus-1-order9 (function float float)) +(define-extern logf (function float float)) +(define-extern log2f (function float float)) +(define-extern exp-slead (pointer float)) +(define-extern exp-strail (pointer float)) +(define-extern exp (function float float)) +(define-extern pow (function float float float)) +(define-extern print-exp (function float none)) +(define-extern print-time (function object time-frame none)) +(define-extern log2 (function int int)) +(define-extern seek (function float float float float)) +(define-extern seek-ease (function float float float float float float)) +(define-extern seek-ease-in-out (function float float float float float float float float)) +(define-extern lerp (function float float float float)) +(define-extern lerp-scale-old (function float float float float float float)) +(define-extern lerp-scale (function float float float float float float)) +(define-extern lerp-clamp (function float float float float)) +(define-extern seekl (function int int int int)) +(define-extern rand-vu-init (function float float)) +(define-extern rand-vu (function float)) +(define-extern rand-vu-nostep (function float)) +(define-extern rand-vu-float-range (function float float float)) +(define-extern rand-vu-percent? (function float symbol)) +(define-extern rand-vu-int-range (function int int int)) +(define-extern rand-vu-int-count (function int int)) +(define-extern rand-vu-int-count-excluding (function int int int)) +(define-extern rand-vu-int-range-exclude (function int int int int)) +(define-extern *random-generator* random-generator) +(define-extern rand-uint31-gen (function random-generator uint)) +(define-extern cube-root (function float float)) +(define-extern int-noise (function int float)) +(define-extern smooth-step (function float float)) +(define-extern smooth-interp (function float float float float float float)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; vector-h ;; @@ -836,398 +854,329 @@ ) |# -#| + (deftype bit-array (basic) ((length int32 :offset-assert 4) (allocated-length int32 :offset-assert 8) + (_pad uint8 :offset-assert 12) + (bytes uint8 :dynamic :offset 12) ) :method-count-assert 13 :size-assert #xd :flag-assert #xd0000000d (:methods - ;; (new (symbol type int) _type_ 0) - (dummy-9 () none 9) ;; (get-bit (_type_ int) symbol 9) - (dummy-10 () none 10) ;; (clear-bit (_type_ int) int 10) - (dummy-11 () none 11) ;; (set-bit (_type_ int) int 11) - (dummy-12 () none 12) ;; (clear-all! (_type_) _type_ 12) + (new (symbol type int) _type_ 0) + (get-bit (_type_ int) symbol 9) + (clear-bit (_type_ int) int 10) + (set-bit (_type_ int) int 11) + (clear-all! (_type_) _type_ 12) ) ) -|# -#| + (deftype vector16ub (structure) - ((data UNKNOWN 16 :offset-assert 0) - (quad uint128 :offset-assert 0) + ((data uint8 16 :offset-assert 0) + (quad uint128 :offset 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype vector4ub (structure) - ((data uint8 4 :offset-assert 0) ;; guessed by decompiler - (x uint8 :offset-assert 0) - (y uint8 :offset-assert 1) - (z uint8 :offset-assert 2) - (w uint8 :offset-assert 3) - (clr uint32 :offset-assert 0) + ((data uint8 4 :offset-assert 0) + (x uint8 :offset 0) + (y uint8 :offset 1) + (z uint8 :offset 2) + (w uint8 :offset 3) + (clr uint32 :offset 0) ) :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 ) -|# -#| (deftype vector4b (structure) - ((data int8 4 :offset-assert 0) ;; guessed by decompiler - (x int8 :offset-assert 0) - (y int8 :offset-assert 1) - (z int8 :offset-assert 2) - (w int8 :offset-assert 3) - (clr int32 :offset-assert 0) + ((data int8 4 :offset-assert 0) + (x int8 :offset 0) + (y int8 :offset 1) + (z int8 :offset 2) + (w int8 :offset 3) + (clr int32 :offset 0) ) :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 ) -|# -#| (deftype vector2ub (structure) - ((data UNKNOWN 2 :offset-assert 0) - (x uint8 :offset-assert 0) - (y uint8 :offset-assert 1) - (clr uint16 :offset-assert 0) + ((data uint8 2 :offset-assert 0) + (x uint8 :offset 0) + (y uint8 :offset 1) + (clr uint16 :offset 0) ) :method-count-assert 9 :size-assert #x2 :flag-assert #x900000002 ) -|# -#| (deftype vector2b (structure) - ((data UNKNOWN 2 :offset-assert 0) - (x int8 :offset-assert 0) - (y int8 :offset-assert 1) - (clr int16 :offset-assert 0) + ((data int8 2 :offset-assert 0) + (x int8 :offset 0) + (y int8 :offset 1) + (clr int16 :offset 0) ) :method-count-assert 9 :size-assert #x2 :flag-assert #x900000002 ) -|# -#| (deftype vector2h (structure) - ((data int16 2 :offset-assert 0) ;; guessed by decompiler - (x int16 :offset-assert 0) - (y int16 :offset-assert 2) + ((data int16 2 :offset-assert 0) + (x int16 :offset 0) + (y int16 :offset 2) ) :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 ) -|# -#| (deftype vector2uh (structure) - ((data uint16 2 :offset-assert 0) ;; guessed by decompiler - (x uint16 :offset-assert 0) - (y uint16 :offset-assert 2) - (val uint32 :offset-assert 0) + ((data uint16 2 :offset-assert 0) + (x uint16 :offset 0) + (y uint16 :offset 2) + (val uint32 :offset 0) ) :method-count-assert 9 :size-assert #x4 :flag-assert #x900000004 ) -|# -#| (deftype vector3h (structure) - ((data int16 3 :offset-assert 0) ;; guessed by decompiler - (x int16 :offset-assert 0) - (y int16 :offset-assert 2) - (z int16 :offset-assert 4) + ((data int16 3 :offset-assert 0) + (x int16 :offset 0) + (y int16 :offset 2) + (z int16 :offset 4) ) :method-count-assert 9 :size-assert #x6 :flag-assert #x900000006 ) -|# -#| (deftype vector3uh (structure) - ((data UNKNOWN 3 :offset-assert 0) - (x uint16 :offset-assert 0) - (y uint16 :offset-assert 2) - (z uint16 :offset-assert 4) + ((data uint16 3 :offset-assert 0) + (x uint16 :offset 0) + (y uint16 :offset 2) + (z uint16 :offset 4) ) :method-count-assert 9 :size-assert #x6 :flag-assert #x900000006 ) -|# -#| (deftype vector2w (structure) - ((data int32 2 :offset-assert 0) ;; guessed by decompiler - (x int32 :offset-assert 0) - (y int32 :offset-assert 4) + ((data int32 2 :offset-assert 0) + (x int32 :offset 0) + (y int32 :offset 4) ) :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype vector3w (structure) - ((data int32 3 :offset-assert 0) ;; guessed by decompiler - (x int32 :offset-assert 0) - (y int32 :offset-assert 4) - (z int32 :offset-assert 8) + ((data int32 3 :offset-assert 0) + (x int32 :offset 0) + (y int32 :offset 4) + (z int32 :offset 8) ) :method-count-assert 9 :size-assert #xc :flag-assert #x90000000c ) -|# -#| (deftype vector4w (structure) - ((data uint32 4 :offset-assert 0) ;; guessed by decompiler - (x int32 :offset-assert 0) - (y int32 :offset-assert 4) - (z int32 :offset-assert 8) - (w int32 :offset-assert 12) - (dword uint64 2 :offset-assert 0) ;; guessed by decompiler - (quad uint128 :offset-assert 0) + ((data uint32 4 :offset-assert 0) + (x int32 :offset 0) + (y int32 :offset 4) + (z int32 :offset 8) + (w int32 :offset 12) + (dword uint64 2 :offset 0) + (quad uint128 :offset 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype vector2 (structure) - ((data UNKNOWN 2 :offset-assert 0) - (x float :offset-assert 0) - (y float :offset-assert 4) + ((data float 2 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) ) :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype vector3 (structure) - ((data UNKNOWN 3 :offset-assert 0) - (x float :offset-assert 0) - (y float :offset-assert 4) - (z float :offset-assert 8) + ((data float 3 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (z float :offset 8) ) :method-count-assert 9 :size-assert #xc :flag-assert #x90000000c ) -|# -#| (deftype vector4 (structure) - ((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) - (dword UNKNOWN 2 :offset-assert 0) - (quad uint128 :offset-assert 0) + ((data float 4 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (z float :offset 8) + (w float :offset 12) + (dword uint64 2 :offset 0) + (quad uint128 :offset 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype vector4w-2 (structure) - ((data int32 8 :offset-assert 0) ;; guessed by decompiler - (quad uint128 2 :offset-assert 0) ;; guessed by decompiler - (vector vector4w 2 :offset-assert 0) ;; guessed by decompiler + ((data int32 8 :offset-assert 0) + (quad uint128 2 :offset 0) + (vector vector4w 2 :inline :offset 0) ) :method-count-assert 9 :size-assert #x20 :flag-assert #x900000020 ) -|# -#| (deftype vector4w-3 (structure) - ((data int32 12 :offset-assert 0) ;; guessed by decompiler - (quad uint128 3 :offset-assert 0) ;; guessed by decompiler - (vector vector4w 3 :offset-assert 0) ;; guessed by decompiler + ((data int32 12 :offset-assert 0) + (quad uint128 3 :offset 0) + (vector vector4w 3 :inline :offset 0) ) :method-count-assert 9 :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype vector4w-4 (structure) - ((data int32 16 :offset-assert 0) ;; guessed by decompiler - (quad uint128 4 :offset-assert 0) ;; guessed by decompiler - (vector vector4w 4 :offset-assert 0) ;; guessed by decompiler + ((data int32 16 :offset-assert 0) + (quad uint128 4 :offset 0) + (vector vector4w 4 :inline :offset 0) ) :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 ) -|# -#| (deftype vector4h (structure) - ((data int16 4 :offset-assert 0) ;; guessed by decompiler - (x int16 :offset-assert 0) - (y int16 :offset-assert 2) - (z int16 :offset-assert 4) - (w int16 :offset-assert 6) - (long uint64 :offset-assert 0) + ((data int16 4 :offset-assert 0) + (x int16 :offset 0) + (y int16 :offset 2) + (z int16 :offset 4) + (w int16 :offset 6) + (long uint64 :offset 0) ) :method-count-assert 9 :size-assert #x8 :flag-assert #x900000008 ) -|# -#| (deftype vector8h (structure) - ((data int16 8 :offset-assert 0) ;; guessed by decompiler - (quad uint128 :offset-assert 0) + ((data int16 8 :offset-assert 0) + (quad uint128 :offset 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype vector16b (structure) - ((data int8 16 :offset-assert 0) ;; guessed by decompiler - (quad uint128 :offset-assert 0) + ((data int8 16 :offset-assert 0) + (quad uint128 :offset 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype vector4s-3 (structure) - ((data float 12 :offset-assert 0) ;; guessed by decompiler - (quad uint128 3 :offset-assert 0) ;; guessed by decompiler - (vector vector 3 :offset-assert 0) ;; guessed by decompiler + ((data float 12 :offset-assert 0) + (quad uint128 3 :offset 0) + (vector vector 3 :inline :offset 0) ) :method-count-assert 9 :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype vector-array (inline-array-class) - ((data vector :dynamic :offset-assert 16) ;; guessed by decompiler + ((data vector :inline :dynamic :offset-assert 16) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype rgbaf (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) - (r float :offset-assert 0) - (g float :offset-assert 4) - (b float :offset-assert 8) - (a float :offset-assert 12) + ((r float :offset 0) + (g float :offset 4) + (b float :offset 8) + (a float :offset 12) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype plane (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) - (a float :offset-assert 0) - (b float :offset-assert 4) - (c float :offset-assert 8) - (d float :offset-assert 12) + ((a float :offset 0) + (b float :offset 4) + (c float :offset 8) + (d float :offset 12) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype sphere (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) - (r float :offset-assert 12) + ((r float :offset 12) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| +(deftype isphere (vec4s) + () + ) + (deftype box8s (structure) - ((data float 8 :offset-assert 0) ;; guessed by decompiler - (quad uint128 2 :offset-assert 0) ;; guessed by decompiler - (vector vector 2 :offset-assert 0) ;; guessed by decompiler - (min vector :inline :offset-assert 0) - (max vector :inline :offset-assert 16) + ((data float 8 :offset-assert 0) + (quad uint128 2 :offset 0) + (vector vector 2 :offset 0) + (min vector :inline :offset 0) + (max vector :inline :offset 16) ) :method-count-assert 9 :size-assert #x20 :flag-assert #x900000020 ) -|# -#| (deftype box8s-array (inline-array-class) - ((data box8s :dynamic :offset-assert 16) ;; guessed by decompiler + ((data box8s :inline :dynamic :offset-assert 16) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype cylinder (structure) ((origin vector :inline :offset-assert 0) (axis vector :inline :offset-assert 16) @@ -1238,13 +1187,11 @@ :size-assert #x28 :flag-assert #xb00000028 (:methods - (dummy-9 () none 9) ;; (debug-draw (_type_ vector4w) none 9) - (dummy-10 () none 10) ;; (ray-capsule-intersect (_type_ vector vector) float 10) + (debug-draw (_type_ vector4w) none 9) + (ray-capsule-intersect (_type_ vector vector) float 10) ) ) -|# -#| (deftype cylinder-flat (structure) ((origin vector :inline :offset-assert 0) (axis vector :inline :offset-assert 16) @@ -1255,81 +1202,72 @@ :size-assert #x28 :flag-assert #xb00000028 (:methods - (dummy-9 () none 9) ;; (debug-draw (_type_ vector4w) none 9) - (dummy-10 () none 10) ;; (ray-flat-cyl-intersect (_type_ vector vector) float 10) + (debug-draw (_type_ vector4w) none 9) + (ray-flat-cyl-intersect (_type_ vector vector) float 10) ) ) -|# -#| (deftype vertical-planes (structure) - ((data uint128 4 :offset-assert 0) ;; guessed by decompiler + ((data uint128 4 :offset-assert 0) ) :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 ) -|# -#| (deftype vertical-planes-array (basic) - ((length uint32 :offset-assert 4) - (data vertical-planes :dynamic :offset-assert 16) ;; guessed by decompiler + ((length uint32 :offset-assert 4) + (data vertical-planes :inline :dynamic :offset-assert 16) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype qword (structure) - ((data uint32 4 :offset-assert 0) ;; guessed by decompiler - (byte uint8 16 :offset-assert 0) ;; guessed by decompiler - (hword uint16 8 :offset-assert 0) ;; guessed by decompiler - (word uint32 4 :offset-assert 0) ;; guessed by decompiler - (dword uint64 2 :offset-assert 0) ;; guessed by decompiler - (quad uint128 :offset-assert 0) - (vector vector :inline :offset-assert 0) - (vector4w vector4w :inline :offset-assert 0) + ((data uint32 4 :offset-assert 0) + (byte uint8 16 :offset 0) + (hword uint16 8 :offset 0) + (word uint32 4 :offset 0) + (dword uint64 2 :offset 0) + (quad uint128 :offset 0) + (vector vector :inline :offset 0) + (vector4w vector4w :inline :offset 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -#| (deftype vector3s (structure) - ((data float 3 :offset-assert 0) ;; guessed by decompiler - (x float :offset-assert 0) - (y float :offset-assert 4) - (z float :offset-assert 8) + ((data float 3 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (z float :offset 8) ) :method-count-assert 9 :size-assert #xc :flag-assert #x90000000c ) -|# -;; (define-extern *null-vector* object) ;; vector -;; (define-extern *identity-vector* object) ;; vector -;; (define-extern *x-vector* object) ;; vector -;; (define-extern *y-vector* object) ;; vector -;; (define-extern *z-vector* object) ;; vector -;; (define-extern *up-vector* object) ;; vector -;; (define-extern vector-dot object) ;; (function vector vector float) -;; (define-extern vector-dot-vu object) ;; (function vector vector float) -;; (define-extern vector4-dot object) ;; (function vector vector float) -;; (define-extern vector4-dot-vu object) ;; (function vector vector float) -;; (define-extern vector+! object) ;; (function vector vector vector vector) -;; (define-extern vector-! object) ;; (function vector vector vector vector) -;; (define-extern vector-zero! object) ;; (function vector vector) -;; (define-extern vector-reset! object) ;; (function vector vector) -;; (define-extern vector-copy! object) ;; (function vector vector vector) -;; (define-extern vector-length< object) -;; (define-extern vector-length> object) -;; (define-extern *zero-vector* object) ;; vector +(define-extern *null-vector* vector) +(define-extern *identity-vector* vector) +(define-extern *x-vector* vector) +(define-extern *y-vector* vector) +(define-extern *z-vector* vector) +(define-extern *up-vector* vector) +(define-extern vector-dot (function vector vector float)) +(define-extern vector-dot-vu (function vector vector float)) +(define-extern vector4-dot (function vector vector float)) +(define-extern vector4-dot-vu (function vector vector float)) +(define-extern vector+! (function vector vector vector vector)) +(define-extern vector-! (function vector vector vector vector)) +(define-extern vector-zero! (function vector vector)) +(define-extern vector-reset! (function vector vector)) +(define-extern vector-copy! (function vector vector vector)) +(define-extern vector-length< (function vector float symbol)) +(define-extern vector-length> (function vector float symbol)) +(define-extern *zero-vector* vector) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; gravity-h ;; @@ -1340,7 +1278,6 @@ ;; bounding-box-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype bounding-box (structure) ((min vector :inline :offset-assert 0) (max vector :inline :offset-assert 16) @@ -1349,23 +1286,22 @@ :size-assert #x20 :flag-assert #x1500000020 (:methods - (dummy-9 () none 9) ;; (add-spheres! (_type_ (inline-array sphere) int) int 9) - (dummy-10 () none 10) ;; (add-point! (_type_ vector3s) int 10) - (dummy-11 () none 11) ;; (set-from-point-offset! (_type_ vector3s vector3s) int 11) - (dummy-12 () none 12) ;; (set-from-point-offset-pad! (_type_ vector3s vector3s float) int 12) - (dummy-13 () none 13) ;; (set-from-sphere! (_type_ sphere) int 13) - (dummy-14 () none 14) ;; (set-from-spheres! (_type_ (inline-array sphere) int) int 14) - (dummy-15 () none 15) ;; (add-box! (_type_ bounding-box) int 15) - (dummy-16 () none 16) - (dummy-17 () none 17) - (dummy-18 () none 18) - (dummy-19 () none 19) - (dummy-20 () none 20) + (add-spheres! (_type_ (inline-array sphere) int) int 9) + (add-box! (_type_ bounding-box) int 10) + (add-point! (_type_ vector) none 11) + (intersects-line-segment? (_type_ vector vector) symbol 12) + (set-from-point-offset! (_type_ vector vector) none 13) + (set-from-point-offset-pad! (_type_ vector vector float) int 14) + (set-to-point! (_type_ vector vector float) none 15) + (set-from-sphere! (_type_ sphere) none 16) + (set-from-spheres! (_type_ (inline-array sphere) int) int 17) + (get-bounding-sphere (_type_ vector) vector 18) + (inside-xyz? (bounding-box vector) symbol 19) + (inside-xz? (bounding-box vector) symbol 20) ) ) -|# -#| + (deftype bounding-box4w (structure) ((min vector4w :inline :offset-assert 0) (max vector4w :inline :offset-assert 16) @@ -1374,9 +1310,9 @@ :size-assert #x20 :flag-assert #x900000020 ) -|# -#| + + (deftype bounding-box-both (structure) ((box bounding-box :inline :offset-assert 0) (box4w bounding-box4w :inline :offset-assert 32) @@ -1385,114 +1321,97 @@ :size-assert #x40 :flag-assert #x900000040 ) -|# -#| + + (deftype bounding-box-array (inline-array-class) - ((data UNKNOWN :dynamic :offset-assert 16) + ((data bounding-box :inline :dynamic :offset-assert 16) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; matrix-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype matrix (structure) - ((data float 16 :offset-assert 0) ;; guessed by decompiler - (vector vector 4 :offset-assert 0) ;; guessed by decompiler - (quad uint128 4 :offset-assert 0) ;; guessed by decompiler - (trans vector :inline :offset-assert 48) + ((data float 16 :offset-assert 0) + (vector vector 4 :offset 0) + (quad uint128 4 :offset 0) + (trans vector :inline :offset 48) ) :method-count-assert 10 :size-assert #x40 :flag-assert #xa00000040 (:methods - (dummy-9 () none 9) ;; (transform-vectors! (_type_ (inline-array vector) (inline-array vector) int) none 9) + (transform-vectors! (_type_ (inline-array vector) (inline-array vector) int) none 9) ) ) -|# -#| (deftype matrix3 (structure) - ((data float 12 :offset-assert 0) ;; guessed by decompiler - (vector vector 3 :offset-assert 0) ;; guessed by decompiler - (quad uint128 3 :offset-assert 0) ;; guessed by decompiler + ((data float 12 :offset-assert 0) + (vector vector 3 :offset 0) + (quad uint128 3 :offset 0) ) :method-count-assert 9 :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype matrix4h (structure) - ((data int16 16 :offset-assert 0) ;; guessed by decompiler - (vector4h vector4h 4 :offset-assert 0) ;; guessed by decompiler - (long int64 4 :offset-assert 0) ;; guessed by decompiler + ((data int16 16 :offset-assert 0) + (vector4h vector4h 4 :offset 0) + (long int64 4 :offset 0) ) :method-count-assert 9 :size-assert #x20 :flag-assert #x900000020 ) -|# -;; (define-extern matrix-copy! object) ;; (function matrix matrix matrix) +(define-extern matrix-copy! (function matrix matrix matrix)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; quaternion-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype quaternion (structure) - ((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) - (vec vector :inline :offset-assert 0) - (quad uint128 :offset-assert 0) + ((data float 4 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (z float :offset 8) + (w float :offset 12) + (vec vector :inline :offset 0) + (quad uint128 :offset 0) ) :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -;; (define-extern *unity-quaternion* object) ;; quaternion +(define-extern *unity-quaternion* quaternion) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; euler-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype euler-angles (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) - ) + () :method-count-assert 9 :size-assert #x10 :flag-assert #x900000010 ) -|# -;; (define-extern EulSafe object) ;; (array int32) -;; (define-extern EulNext object) ;; (array int32) +(define-extern EulSafe (array int32)) +(define-extern EulNext (array int32)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; transform-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype transform (structure) ((trans vector :inline :offset-assert 0) (rot vector :inline :offset-assert 16) @@ -1502,9 +1421,7 @@ :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype trs (basic) ((trans vector :inline :offset-assert 16) (rot vector :inline :offset-assert 32) @@ -1514,18 +1431,15 @@ :size-assert #x40 :flag-assert #x900000040 ) -|# - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; geometry-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype curve (structure) - ((cverts (inline-array vector) :offset-assert 0) ;; guessed by decompiler + ((cverts (inline-array vector) :offset-assert 0) (num-cverts int32 :offset-assert 4) - (knots (pointer float) :offset-assert 8) ;; guessed by decompiler + (knots (pointer float) :offset-assert 8) (num-knots int32 :offset-assert 12) (length float :offset-assert 16) ) @@ -1533,11 +1447,9 @@ :size-assert #x14 :flag-assert #x900000014 ) -|# -#| (deftype border-plane (basic) - ((name symbol :offset-assert 4) ;; guessed by decompiler + ((name symbol :offset-assert 4) (action basic :offset-assert 8) (slot int8 :offset-assert 12) (trans vector :inline :offset-assert 16) @@ -1547,11 +1459,10 @@ :size-assert #x30 :flag-assert #xb00000030 (:methods - (dummy-9 () none 9) ;; (debug-draw! (_type_) none 9) - (dummy-10 () none 10) ;; (point-past-plane? (_type_ vector) symbol 10) + (debug-draw! (_type_) none 9) + (point-past-plane? (_type_ vector) symbol 10) ) ) -|# ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -1563,30 +1474,25 @@ ;; transformq-h ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype transformq (transform) - ((quat quaternion :inline :offset-assert 16) + ((quat quaternion :inline :offset 16) ) :method-count-assert 9 :size-assert #x30 :flag-assert #x900000030 ) -|# -#| (deftype trsq (trs) - ((quat quaternion :inline :offset-assert 32) + ((quat quaternion :inline :offset 32) ) :method-count-assert 9 :size-assert #x40 :flag-assert #x900000040 ) -|# -#| (deftype trsqv (trsq) - ((pause-adjust-distance meters :offset-assert 4) - (nav-radius meters :offset-assert 8) + ((pause-adjust-distance meters :offset 4) + (nav-radius meters :offset 8) (transv vector :inline :offset-assert 64) (rotv vector :inline :offset-assert 80) (scalev vector :inline :offset-assert 96) @@ -1611,22 +1517,20 @@ (dummy-19 () none 19) ;; (set-heading-vec-clear-roll-pitch! (_type_ vector) quaternion 19) (dummy-20 () none 20) ;; (point-toward-point-clear-roll-pitch! (_type_ vector) quaternion 20) (dummy-21 () none 21) ;; (rot->dir-targ! (_type_) quaternion 21) - (dummy-22 () none 22) ;; (y-angle (_type_) float 22) - (dummy-23 () none 23) ;; (global-y-angle-to-point (_type_ vector) float 23) - (dummy-24 () none 24) ;; (relative-y-angle-to-point (_type_ vector) float 24) + (y-angle (_type_) float 22) + (global-y-angle-to-point (_type_ vector) float 23) + (relative-y-angle-to-point (_type_ vector) float 24) (dummy-25 () none 25) ;; (roll-relative-to-gravity (_type_) float 25) (dummy-26 () none 26) ;; (set-and-limit-velocity (_type_ int vector float) trsqv 26) (dummy-27 () none 27) ;; (get-quaternion (_type_) quaternion 27) ) ) -|# ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; bounding-box ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| (deftype liang-barsky-line-clip-params (structure) ((te float :offset-assert 0) (tl float :offset-assert 4) @@ -1635,99 +1539,75 @@ :size-assert #x8 :flag-assert #x900000008 ) -|# -;; (define-extern box-vector-enside? object) ;; (function bounding-box vector symbol) -;; (define-extern box-vector-inside? object) ;; (function bounding-box vector symbol) -;; (define-extern liang-barsky-line-clipt object) +(define-extern box-vector-enside? (function bounding-box vector symbol)) +(define-extern box-vector-inside? (function bounding-box vector symbol)) +(define-extern liang-barsky-line-clipt (function liang-barsky-line-clip-params float float symbol)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; matrix ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -#| -(deftype matrix (structure) - () - :method-count-assert 10 - :size-assert #x40 - :flag-assert #xa00000040 - ;; Failed to read fields. - (:methods - (dummy-9 () none 9) ;; (transform-vectors! (_type_ (inline-array vector) (inline-array vector) int) none 9) - ) - ) -|# - -#| -(deftype matrix3 (structure) - () - :method-count-assert 9 - :size-assert #x30 - :flag-assert #x900000030 - ;; Failed to read fields. - ) -|# - -;; (define-extern matrix-identity! object) ;; (function matrix matrix) -;; (define-extern *identity-matrix* object) ;; matrix -;; (define-extern *hermite-matrix* object) -;; (define-extern matrix+! object) ;; (function matrix matrix matrix matrix) -;; (define-extern matrix-! object) ;; (function matrix matrix matrix matrix) -;; (define-extern matrix*! object) ;; (function matrix matrix matrix matrix) -;; (define-extern matrixp*! object) ;; (function matrix matrix matrix matrix) -;; (define-extern vector-matrix*! object) ;; (function vector vector matrix vector) -;; (define-extern vector-rotate*! object) ;; (function vector vector matrix vector) -;; (define-extern vector3s-matrix*! object) ;; (function vector3s vector3s matrix vector3s) -;; (define-extern vector3s-rotate*! object) ;; (function vector3s vector3s matrix vector3s) -;; (define-extern matrix-transpose! object) ;; (function matrix matrix matrix) -;; (define-extern matrix-inverse-of-rot-trans! object) ;; (function matrix matrix matrix) -;; (define-extern matrix-4x4-inverse! object) ;; (function matrix matrix matrix) -;; (define-extern matrix-translate! object) ;; (function matrix vector matrix) -;; (define-extern matrix-translate+! object) ;; (function matrix matrix vector matrix) -;; (define-extern matrix-scale! object) ;; (function matrix vector matrix) -;; (define-extern scale-matrix! object) ;; (function matrix vector matrix matrix) -;; (define-extern matrix-inv-scale! object) ;; (function matrix vector matrix) -;; (define-extern column-scale-matrix! object) ;; (function matrix vector matrix matrix) -;; (define-extern matrix-rotate-x! object) ;; (function matrix float matrix) -;; (define-extern matrix-rotate-y! object) ;; (function matrix float matrix) -;; (define-extern matrix-rotate-z! object) ;; (function matrix float matrix) -;; (define-extern matrix-rotate-zyx! object) ;; (function matrix vector matrix) -;; (define-extern matrix-rotate-xyz-2! object) -;; (define-extern matrix-rotate-xyz! object) ;; (function matrix vector matrix) -;; (define-extern matrix-rotate-zxy! object) ;; (function matrix vector matrix) -;; (define-extern matrix-rotate-yxz! object) ;; (function matrix vector matrix) -;; (define-extern matrix-rotate-yzx! object) ;; (function matrix vector matrix) -;; (define-extern matrix-rotate-yxy! object) ;; (function matrix vector matrix) -;; (define-extern matrix-rotate-yx! object) ;; (function matrix float float matrix) -;; (define-extern matrix-axis-sin-cos-vu! object) ;; (function matrix vector float float none) -;; (define-extern matrix-axis-sin-cos! object) ;; (function matrix vector float float matrix) -;; (define-extern matrix-axis-angle! object) ;; (function matrix vector float none) -;; (define-extern matrix-lerp! object) ;; (function matrix matrix matrix float matrix) -;; (define-extern matrix-3x3-determinant object) ;; (function matrix float) -;; (define-extern matrix3-determinant object) ;; (function matrix float) -;; (define-extern matrix-3x3-inverse! object) ;; (function matrix matrix matrix) -;; (define-extern matrix-3x3-inverse-transpose! object) ;; (function matrix matrix matrix) -;; (define-extern matrix3-inverse-transpose! object) ;; (function matrix matrix matrix) -;; (define-extern matrix-3x3-normalize! object) -;; (define-extern matrix-4x4-determinant object) ;; (function matrix float) -;; (define-extern matrix-4x4-inverse-transpose! object) ;; (function matrix matrix matrix) -;; (define-extern matrix-y-angle object) ;; (function matrix float) -;; (define-extern matrix->trans object) -;; (define-extern matrix<-trans object) -;; (define-extern matrix->scale object) -;; (define-extern matrix<-scale object) -;; (define-extern matrix->quat object) -;; (define-extern matrix<-quat object) -;; (define-extern matrix->transformq object) -;; (define-extern matrix-mirror! object) +(define-extern matrix-identity! (function matrix matrix)) +(define-extern *identity-matrix* matrix) +(define-extern *hermite-matrix* matrix) +(define-extern matrix+! (function matrix matrix matrix matrix)) +(define-extern matrix-! (function matrix matrix matrix matrix)) +(define-extern matrix*! (function matrix matrix matrix matrix)) +(define-extern matrixp*! (function matrix matrix matrix matrix)) +(define-extern vector-matrix*! (function vector vector matrix vector)) +(define-extern vector-rotate*! (function vector vector matrix vector)) +(define-extern vector3s-matrix*! (function vector3s vector3s matrix vector3s)) +(define-extern vector3s-rotate*! (function vector3s vector3s matrix vector3s)) +(define-extern matrix-transpose! (function matrix matrix matrix)) +(define-extern matrix-inverse-of-rot-trans! (function matrix matrix matrix)) +(define-extern matrix-4x4-inverse! (function matrix matrix matrix)) +(define-extern matrix-translate! (function matrix vector matrix)) +(define-extern matrix-translate+! (function matrix matrix vector matrix)) +(define-extern matrix-scale! (function matrix vector matrix)) +(define-extern scale-matrix! (function matrix vector matrix matrix)) +(define-extern matrix-inv-scale! (function matrix vector matrix)) +(define-extern column-scale-matrix! (function matrix vector matrix matrix)) +(define-extern matrix-rotate-x! (function matrix float matrix)) +(define-extern matrix-rotate-y! (function matrix float matrix)) +(define-extern matrix-rotate-z! (function matrix float matrix)) +(define-extern matrix-rotate-zyx! (function matrix vector matrix)) +(define-extern matrix-rotate-xyz-2! (function matrix vector matrix)) +(define-extern matrix-rotate-xyz! (function matrix vector matrix)) +(define-extern matrix-rotate-zxy! (function matrix vector matrix)) +(define-extern matrix-rotate-yxz! (function matrix vector matrix)) +(define-extern matrix-rotate-yzx! (function matrix vector matrix)) +(define-extern matrix-rotate-yxy! (function matrix vector matrix)) +(define-extern matrix-rotate-yx! (function matrix float float matrix)) +(define-extern matrix-axis-sin-cos-vu! (function matrix vector float float none)) +(define-extern matrix-axis-sin-cos! (function matrix vector float float matrix)) +(define-extern matrix-axis-angle! (function matrix vector float none)) +(define-extern matrix-lerp! (function matrix matrix matrix float matrix)) +(define-extern matrix-3x3-determinant (function matrix float)) +(define-extern matrix3-determinant (function matrix float)) +(define-extern matrix-3x3-inverse! (function matrix matrix matrix)) +(define-extern matrix-3x3-inverse-transpose! (function matrix matrix matrix)) +(define-extern matrix3-inverse-transpose! (function matrix matrix matrix)) +(define-extern matrix-3x3-normalize! (function matrix matrix matrix)) +(define-extern matrix-4x4-determinant (function matrix float)) +(define-extern matrix-4x4-inverse-transpose! (function matrix matrix matrix)) +(define-extern matrix-y-angle (function matrix float)) +(define-extern matrix->trans (function matrix vector vector)) +(define-extern matrix<-trans (function matrix vector matrix)) +(define-extern matrix->scale (function matrix vector vector)) +(define-extern matrix<-scale (function matrix vector matrix)) +(define-extern matrix->quat (function matrix quaternion quaternion)) +(define-extern matrix<-quat (function matrix quaternion matrix)) +(define-extern matrix->transformq (function transformq matrix transformq)) +(define-extern matrix-mirror! (function matrix vector vector matrix)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; transform ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern transform-matrix-calc! object) ;; (function transform matrix matrix) -;; (define-extern transform-matrix-parent-calc! object) ;; (function transform matrix vector matrix) -;; (define-extern trs-matrix-calc! object) ;; (function trs matrix matrix) +(define-extern transform-matrix-calc! (function transform matrix matrix)) +(define-extern transform-matrix-parent-calc! (function transform matrix vector matrix)) +(define-extern trs-matrix-calc! (function trs matrix matrix)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; quaternion ;; @@ -1768,9 +1648,9 @@ ;; (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->matrix object) ;; (function matrix quaternion matrix) +(define-extern quaternion->matrix (function matrix quaternion matrix)) ;; (define-extern quaternion->matrix-2 object) -;; (define-extern matrix->quaternion object) ;; (function quaternion matrix quaternion) +(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) @@ -1798,7 +1678,7 @@ ;; (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 vector-y-angle object) ;; (function vector float) +(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) @@ -1820,13 +1700,13 @@ ;; (define-extern radmod object) ;; (function float float) ;; (define-extern deg- object) ;; (function float float float) -;; (define-extern deg-diff object) ;; (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 sin object) ;; (function float 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 @@ -1839,9 +1719,9 @@ ;; (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 vector-sincos! object) ;; (function vector vector vector int) +(define-extern vector-sincos! (function vector vector vector int)) ;; (define-extern tan-rad object) ;; (function float float) -;; (define-extern cos object) ;; (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) @@ -1850,7 +1730,7 @@ ;; (define-extern sign-float object) ;; (define-extern sign object) ;; (function float float) ;; (define-extern atan2-rad object) ;; (function float float float) -;; (define-extern atan object) ;; (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) @@ -3350,14 +3230,14 @@ ;; vector ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; (define-extern vector-cross! object) ;; (function vector vector vector vector) +(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-float*! object) ;; (function vector vector float 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) @@ -3372,7 +3252,7 @@ ;; (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-identity! object) ;; (function vector vector) +(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) @@ -3383,8 +3263,8 @@ ;; (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-length object) ;; (function vector float) -;; (define-extern vector-length-squared object) ;; (function vector float) +(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) @@ -3392,9 +3272,9 @@ ;; (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-normalize! object) ;; (function vector float vector) +(define-extern vector-normalize! (function vector float vector)) ;; (define-extern vector-normalize-ret-len! object) ;; (function vector float float) -;; (define-extern vector-normalize-copy! object) ;; (function vector vector float vector) +(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) diff --git a/decompiler/config/jak2/hacks.jsonc b/decompiler/config/jak2/hacks.jsonc index 7c07e25eed..5cb4904062 100644 --- a/decompiler/config/jak2/hacks.jsonc +++ b/decompiler/config/jak2/hacks.jsonc @@ -37,7 +37,7 @@ "(anon-function 54 script)", "(anon-function 52 script)", "(anon-function 49 script)", "(anon-function 33 script)", "debug-menu-func-decode", "scene-player-init", "(method 77 spyder)", "(method 77 flamer)", "(method 77 grenadier)", "(method 224 bot)", "(method 77 rapid-gunner)", // until loop without nop: - "rand-vu-int-count-excluding", "rand-vu-int-range-exclude", "(method 9 history)", "history-print", "history-draw", + "(method 9 history)", "history-print", "history-draw", "(method 9 sparticle-launcher)", "(method 18 tracking-spline)", "cam-string-find-position-rel!", "cam-layout-entity-volume-info-create", "process-drawable-shock-skel-effect", "target-history-print", "display-list-control", "anim-test-anim-list-handler", "anim-test-sequence-list-handler", "anim-tester-get-playing-item", "(method 9 mysql-nav-graph)", "(method 58 nav-graph-editor)", @@ -47,7 +47,7 @@ // actual asm "quad-copy!", "return-from-thread", "return-from-thread-dead", "reset-and-call", "(method 10 cpu-thread)", "(method 11 cpu-thread)", "(method 0 catch-frame)", "throw-dispatch", "throw", "run-function-in-process", - "set-to-run-bootstrap", "return-from-exception", + "set-to-run-bootstrap", "return-from-exception", "exp", "symlink2", "blerc-a-fragment", "blerc-execute", "foreground-check-longest-edge-asm", "generic-light-proc", "shadow-add-single-edges","shadow-add-facing-single-tris", "shadow-add-double-tris", "shadow-add-double-edges", diff --git a/decompiler/config/jak2/label_types.jsonc b/decompiler/config/jak2/label_types.jsonc index f14f1120e6..a782aa9df3 100644 --- a/decompiler/config/jak2/label_types.jsonc +++ b/decompiler/config/jak2/label_types.jsonc @@ -1,5 +1,28 @@ { "profile": [ ["L14", "profile-work"] + ], + + "math": [ + ["L103", "(pointer float)", 32], + ["L102", "(pointer float)", 32] + ], + + // possible for auto-labeling + "vector-h": [ + ["L36", "vector"], + ["L35", "vector"], + ["L34", "vector"], + ["L33", "vector"], + ["L32", "vector"], + ["L31", "vector"], + ["L30", "vector"] + ], + + "matrix": [ + ["L65", "matrix"] + ], + "quaternion-h": [ + ["L1", "quaternion"] ] } \ No newline at end of file diff --git a/decompiler/config/jak2/stack_structures.jsonc b/decompiler/config/jak2/stack_structures.jsonc index 34c387cbf9..a315e9cbb3 100644 --- a/decompiler/config/jak2/stack_structures.jsonc +++ b/decompiler/config/jak2/stack_structures.jsonc @@ -1,4 +1,63 @@ { + // possible for automatic detection: + "(method 23 trsqv)": [[16, "vector"]], + "(method 24 trsqv)": [[16, "vector"]], + "(method 18 bounding-box)": [[16, "vector"], [32, "vector"]], + "(method 12 bounding-box)": [[16, "liang-barsky-line-clip-params"]], + "matrixp*!": [[16, "matrix"]], + "vector3s-matrix*!": [[16, "vector"]], + "vector3s-rotate*!": [[16, "vector"]], + + "matrix-rotate-zyx!": [ + [16, "matrix"], + [80, "matrix"] + ], + "matrix-rotate-xyz!": [ + [16, "vector"], + [32, "vector"], + [80, "matrix"] + ], + "matrix-rotate-zxy!": [ + [16, "matrix"], + [80, "matrix"] + ], + "matrix-rotate-yxz!": [ + [16, "matrix"], + [80, "matrix"] + ], + "matrix-rotate-yzx!": [ + [16, "matrix"], + [80, "matrix"] + ], + "matrix-rotate-yxy!": [ + [16, "vector"], + [32, "vector"], + [48, "vector"] + ], + "matrix-rotate-yx!": [[16, "matrix"]], + "transform-matrix-calc!": [ + [16, "matrix"], + [80, "matrix"] + ], + "transform-matrix-parent-calc!": [ + [16, "matrix"], + [80, "matrix"] + ], + "matrix->quat": [ + [16, "matrix"] + ], + "matrix<-quat": [ + [16, "vector"], + [32, "matrix"] + ], + "matrix->transformq": [ + [16, "matrix"] + ], + "matrix-rotate-xyz-2!": [ + [16, "matrix"], + [80, "matrix"] + ], + "matrix-with-scale->quaternion": [[16, "matrix"]], "placeholder-do-not-add-below!": [] } diff --git a/decompiler/config/jak2/type_casts.jsonc b/decompiler/config/jak2/type_casts.jsonc index e41bbd92cc..3955d37cdf 100644 --- a/decompiler/config/jak2/type_casts.jsonc +++ b/decompiler/config/jak2/type_casts.jsonc @@ -65,5 +65,29 @@ [101, "t9", "(function object object object object object object none)"] ], "send-event-function": [[[7, 15], "a0", "process"]], + + "logf": [ + [12, "f0", "float"], + [12, "f1", "float"], + [19, "f0", "float"], + [19, "f1", "float"] + ], + + "log2f": [ + [12, "f0", "float"], + [12, "f1", "float"], + [19, "f0", "float"], + [19, "f1", "float"] + ], + + "log2": [[3, "v1", "int"]], + + "cube-root": [ + [[0,33], "f0", "float"], + [[0,33], "f1", "float"], + [[0,33], "f2", "float"] + + ], + "placeholder-do-not-add-below": [] } diff --git a/goal_src/jak2/dgos/engine.gd b/goal_src/jak2/dgos/engine.gd new file mode 100644 index 0000000000..b63aaea6b7 --- /dev/null +++ b/goal_src/jak2/dgos/engine.gd @@ -0,0 +1,371 @@ +("ENGINE.CGO" + ("types-h.o" "types-h") + ("vu1-macros.o" "vu1-macros") + ("math.o" "math") + ("vector-h.o" "vector-h") + ("gravity-h.o" "gravity-h") + ("bounding-box-h.o" "bounding-box-h") + ("matrix-h.o" "matrix-h") + ("quaternion-h.o" "quaternion-h") + ("euler-h.o" "euler-h") + ("transform-h.o" "transform-h") + ("geometry-h.o" "geometry-h") + ("trigonometry-h.o" "trigonometry-h") + ("transformq-h.o" "transformq-h") + ("bounding-box.o" "bounding-box") + ("matrix.o" "matrix") + ("transform.o" "transform") + ("quaternion.o" "quaternion") + ("euler.o" "euler") + ("trigonometry.o" "trigonometry") + ("gsound-h.o" "gsound-h") + ("timer-h.o" "timer-h") + ("vif-h.o" "vif-h") + ("dma-h.o" "dma-h") + ("video-h.o" "video-h") + ("vu1-user-h.o" "vu1-user-h") + ("profile-h.o" "profile-h") + ("dma.o" "dma") + ("dma-buffer.o" "dma-buffer") + ("dma-bucket.o" "dma-bucket") + ("dma-disasm.o" "dma-disasm") + ("pad.o" "pad") + ("gs.o" "gs") + ("display-h.o" "display-h") + ("geometry.o" "geometry") + ("timer.o" "timer") + ("vector.o" "vector") + ("file-io.o" "file-io") + ("loader-h.o" "loader-h") + ("texture-h.o" "texture-h") + ("texture-anim-h.o" "texture-anim-h") + ("lights-h.o" "lights-h") + ("mood-h.o" "mood-h") + ("level-h.o" "level-h") + ("capture-h.o" "capture-h") + ("math-camera-h.o" "math-camera-h") + ("math-camera.o" "math-camera") + ("font-h.o" "font-h") + ("decomp-h.o" "decomp-h") + ("profile.o" "profile") + ("display.o" "display") + ("connect.o" "connect") + ("text-id-h.o" "text-id-h") + ("text-h.o" "text-h") + ("camera-defs-h.o" "camera-defs-h") + ("trail-h.o" "trail-h") + ("minimap-h.o" "minimap-h") + ("bigmap-h.o" "bigmap-h") + ("settings-h.o" "settings-h") + ("capture.o" "capture") + ("memory-usage-h.o" "memory-usage-h") + ("blit-displays-h.o" "blit-displays-h") + ("texture.o" "texture") + ("main-h.o" "main-h") + ("mspace-h.o" "mspace-h") + ("drawable-h.o" "drawable-h") + ("drawable-group-h.o" "drawable-group-h") + ("drawable-inline-array-h.o" "drawable-inline-array-h") + ("draw-node-h.o" "draw-node-h") + ("drawable-tree-h.o" "drawable-tree-h") + ("drawable-actor-h.o" "drawable-actor-h") + ("region-h.o" "region-h") + ("traffic-h.o" "traffic-h") + ("game-task-h.o" "game-task-h") + ("task-control-h.o" "task-control-h") + ("generic-h.o" "generic-h") + ("sky-h.o" "sky-h") + ("ocean-h.o" "ocean-h") + ("ocean-trans-tables.o" "ocean-trans-tables") + ("ocean-tables.o" "ocean-tables") + ("ocean-frames.o" "ocean-frames") + ("time-of-day-h.o" "time-of-day-h") + ("art-h.o" "art-h") + ("generic-vu1-h.o" "generic-vu1-h") + ("merc-h.o" "merc-h") + ("generic-merc-h.o" "generic-merc-h") + ("generic-tie-h.o" "generic-tie-h") + ("generic-work-h.o" "generic-work-h") + ("shadow-cpu-h.o" "shadow-cpu-h") + ("shadow-vu1-h.o" "shadow-vu1-h") + ("memcard-h.o" "memcard-h") + ("game-info-h.o" "game-info-h") + ("gui-h.o" "gui-h") + ("ambient-h.o" "ambient-h") + ("speech-h.o" "speech-h") + ("wind-h.o" "wind-h") + ("prototype-h.o" "prototype-h") + ("joint-h.o" "joint-h") + ("bones-h.o" "bones-h") + ("foreground-h.o" "foreground-h") + ("engines.o" "engines") + ("lightning-h.o" "lightning-h") + ("res-h.o" "res-h") + ("res.o" "res") + ("lights.o" "lights") + ("dynamics-h.o" "dynamics-h") + ("surface-h.o" "surface-h") + ("pat-h.o" "pat-h") + ("fact-h.o" "fact-h") + ("aligner-h.o" "aligner-h") + ("penetrate-h.o" "penetrate-h") + ("game-h.o" "game-h") + ("script-h.o" "script-h") + ("scene-h.o" "scene-h") + ("sync-info-h.o" "sync-info-h") + ("pov-camera-h.o" "pov-camera-h") + ("smush-control-h.o" "smush-control-h") + ("debug-h.o" "debug-h") + ("joint-mod-h.o" "joint-mod-h") + ("collide-func-h.o" "collide-func-h") + ("collide-mesh-h.o" "collide-mesh-h") + ("collide-shape-h.o" "collide-shape-h") + ("generic-obs-h.o" "generic-obs-h") + ("trajectory-h.o" "trajectory-h") + ("collide-target-h.o" "collide-target-h") + ("collide-touch-h.o" "collide-touch-h") + ("collide-edge-grab-h.o" "collide-edge-grab-h") + ("process-drawable-h.o" "process-drawable-h") + ("process-focusable.o" "process-focusable") + ("process-taskable-h.o" "process-taskable-h") + ("focus.o" "focus") + ("effect-control-h.o" "effect-control-h") + ("collide-frag-h.o" "collide-frag-h") + ("collide-hash-h.o" "collide-hash-h") + ("chain-physics-h.o" "chain-physics-h") + ("projectile-h.o" "projectile-h") + ("find-nearest-h.o" "find-nearest-h") + ("target-h.o" "target-h") + ("stats-h.o" "stats-h") + ("bsp-h.o" "bsp-h") + ("collide-cache-h.o" "collide-cache-h") + ("collide-h.o" "collide-h") + ("shrubbery-h.o" "shrubbery-h") + ("tie-h.o" "tie-h") + ("tfrag-h.o" "tfrag-h") + ("background-h.o" "background-h") + ("subdivide-h.o" "subdivide-h") + ("entity-h.o" "entity-h") + ("sprite-h.o" "sprite-h") + ("simple-sprite-h.o" "simple-sprite-h") + ("eye-h.o" "eye-h") + ("sparticle-launcher-h.o" "sparticle-launcher-h") + ("sparticle-h.o" "sparticle-h") + ("actor-link-h.o" "actor-link-h") + ("camera-h.o" "camera-h") + ("cam-debug-h.o" "cam-debug-h") + ("cam-interface-h.o" "cam-interface-h") + ("cam-update-h.o" "cam-update-h") + ("hud-h.o" "hud-h") + ("progress-h.o" "progress-h") + ("rpc-h.o" "rpc-h") + ("path-h.o" "path-h") + ("nav-mesh-h.o" "nav-mesh-h") + ("nav-control-h.o" "nav-control-h") + ("spatial-hash-h.o" "spatial-hash-h") + ("actor-hash-h.o" "actor-hash-h") + ("load-dgo.o" "load-dgo") + ("ramdisk.o" "ramdisk") + ("gsound.o" "gsound") + ("transformq.o" "transformq") + ("collide-func.o" "collide-func") + ("joint.o" "joint") + ("joint-mod.o" "joint-mod") + ("chain-physics.o" "chain-physics") + ("cylinder.o" "cylinder") + ("wind-work.o" "wind-work") + ("wind.o" "wind") + ("bsp.o" "bsp") + ("subdivide.o" "subdivide") + ("sprite.o" "sprite") + ("sprite-distort.o" "sprite-distort") + ("sprite-glow.o" "sprite-glow") + ("debug-sphere.o" "debug-sphere") + ("debug.o" "debug") + ("history.o" "history") + ("merc-vu1.o" "merc-vu1") + ("emerc-vu1.o" "emerc-vu1") + ("merc-blend-shape.o" "merc-blend-shape") + ("merc.o" "merc") + ("emerc.o" "emerc") + ("ripple.o" "ripple") + ("bones.o" "bones") + ("debug-foreground.o" "debug-foreground") + ("foreground.o" "foreground") + ("generic-vu0.o" "generic-vu0") + ("generic-vu1.o" "generic-vu1") + ("generic-effect.o" "generic-effect") + ("generic-merc.o" "generic-merc") + ("generic-tie.o" "generic-tie") + ("shadow-cpu.o" "shadow-cpu") + ("shadow-vu1.o" "shadow-vu1") + ("warp.o" "warp") + ("texture-anim.o" "texture-anim") + ("texture-anim-funcs.o" "texture-anim-funcs") + ("texture-anim-tables.o" "texture-anim-tables") + ("blit-displays.o" "blit-displays") + ("font-data.o" "font-data") + ("font.o" "font") + ("decomp.o" "decomp") + ("background.o" "background") + ("draw-node.o" "draw-node") + ("shrubbery.o" "shrubbery") + ("shrub-work.o" "shrub-work") + ("tfrag-near.o" "tfrag-near") + ("tfrag.o" "tfrag") + ("tfrag-methods.o" "tfrag-methods") + ("tfrag-work.o" "tfrag-work") + ("tie.o" "tie") + ("etie-vu1.o" "etie-vu1") + ("etie-near-vu1.o" "etie-near-vu1") + ("tie-near.o" "tie-near") + ("tie-work.o" "tie-work") + ("tie-methods.o" "tie-methods") + ("sync-info.o" "sync-info") + ("trajectory.o" "trajectory") + ("sparticle-launcher.o" "sparticle-launcher") + ("sparticle.o" "sparticle") + ("entity-table.o" "entity-table") + ("loader.o" "loader") + ("game-info.o" "game-info") + ("game-task.o" "game-task") + ("game-save.o" "game-save") + ("settings.o" "settings") + ("mood-tables.o" "mood-tables") + ("mood-tables2.o" "mood-tables2") + ("mood.o" "mood") + ("mood-funcs.o" "mood-funcs") + ("mood-funcs2.o" "mood-funcs2") + ("weather-part.o" "weather-part") + ("time-of-day.o" "time-of-day") + ("sky-data.o" "sky-data") + ("sky-tng.o" "sky-tng") + ("load-state.o" "load-state") + ("level-info.o" "level-info") + ("level.o" "level") + ("text.o" "text") + ("collide-hash.o" "collide-hash") + ("collide-probe.o" "collide-probe") + ("collide-frag.o" "collide-frag") + ("collide-mesh.o" "collide-mesh") + ("collide-touch.o" "collide-touch") + ("collide-edge-grab.o" "collide-edge-grab") + ("collide-shape.o" "collide-shape") + ("collide-shape-rider.o" "collide-shape-rider") + ("collide.o" "collide") + ("collide-planes.o" "collide-planes") + ("spatial-hash.o" "spatial-hash") + ("actor-hash.o" "actor-hash") + ("merc-death.o" "merc-death") + ("water-flow.o" "water-flow") + ("water-h.o" "water-h") + ("camera.o" "camera") + ("cam-interface.o" "cam-interface") + ("cam-master.o" "cam-master") + ("cam-states.o" "cam-states") + ("cam-states-dbg.o" "cam-states-dbg") + ("cam-combiner.o" "cam-combiner") + ("cam-update.o" "cam-update") + ("vol-h.o" "vol-h") + ("cam-layout.o" "cam-layout") + ("cam-debug.o" "cam-debug") + ("cam-start.o" "cam-start") + ("process-drawable.o" "process-drawable") + ("ambient.o" "ambient") + ("speech.o" "speech") + ("region.o" "region") + ("fma-sphere.o" "fma-sphere") + ("script.o" "script") + ("generic-obs.o" "generic-obs") + ("lightning.o" "lightning") + ("carry-h.o" "carry-h") + ("pilot-h.o" "pilot-h") + ("gun-h.o" "gun-h") + ("board-h.o" "board-h") + ("darkjak-h.o" "darkjak-h") + ("target-util.o" "target-util") + ("target-part.o" "target-part") + ("gun-part.o" "gun-part") + ("collide-reaction-target.o" "collide-reaction-target") + ("logic-target.o" "logic-target") + ("sidekick.o" "sidekick") + ("voicebox.o" "voicebox") + ("collectables-part.o" "collectables-part") + ("debug-part.o" "debug-part") + ("find-nearest.o" "find-nearest") + ("task-arrow.o" "task-arrow") + ("projectile.o" "projectile") + ("target-handler.o" "target-handler") + ("target-anim.o" "target-anim") + ("target.o" "target") + ("target2.o" "target2") + ("target-swim.o" "target-swim") + ("target-carry.o" "target-carry") + ("target-darkjak.o" "target-darkjak") + ("target-death.o" "target-death") + ("target-gun.o" "target-gun") + ("gun-util.o" "gun-util") + ("gun-blue-shot.o" "gun-blue-shot") + ("gun-yellow-shot.o" "gun-yellow-shot") + ("gun-red-shot.o" "gun-red-shot") + ("gun-dark-shot.o" "gun-dark-shot") + ("gun-states.o" "gun-states") + ("board-util.o" "board-util") + ("target-board.o" "target-board") + ("board-part.o" "board-part") + ("board-states.o" "board-states") + ("mech-h.o" "mech-h") + ("menu.o" "menu") + ("drawable.o" "drawable") + ("drawable-group.o" "drawable-group") + ("drawable-inline-array.o" "drawable-inline-array") + ("drawable-tree.o" "drawable-tree") + ("prototype.o" "prototype") + ("main-collide.o" "main-collide") + ("video.o" "video") + ("main.o" "main") + ("collide-cache.o" "collide-cache") + ("collide-debug.o" "collide-debug") + ("relocate.o" "relocate") + ("memory-usage.o" "memory-usage") + ("entity.o" "entity") + ("path.o" "path") + ("vol.o" "vol") + ("nav-mesh.o" "nav-mesh") + ("nav-control.o" "nav-control") + ("aligner.o" "aligner") + ("water.o" "water") + ("collectables.o" "collectables") + ("task-control.o" "task-control") + ("scene.o" "scene") + ("pov-camera.o" "pov-camera") + ("powerups.o" "powerups") + ("crates.o" "crates") + ("hud.o" "hud") + ("hud-classes.o" "hud-classes") + ("progress-static.o" "progress-static") + ("progress.o" "progress") + ("progress-draw.o" "progress-draw") + ("ocean.o" "ocean") + ("ocean-vu0.o" "ocean-vu0") + ("ocean-texture.o" "ocean-texture") + ("ocean-mid.o" "ocean-mid") + ("ocean-transition.o" "ocean-transition") + ("ocean-near.o" "ocean-near") + ("minimap.o" "minimap") + ("bigmap-data.o" "bigmap-data") + ("bigmap.o" "bigmap") + ("eye.o" "eye") + ("glist-h.o" "glist-h") + ("glist.o" "glist") + ("anim-tester.o" "anim-tester") + ("viewer.o" "viewer") + ("part-tester.o" "part-tester") + ("editable-h.o" "editable-h") + ("editable.o" "editable") + ("editable-player.o" "editable-player") + ("mysql-nav-graph.o" "mysql-nav-graph") + ("nav-graph-editor.o" "nav-graph-editor") + ("sampler.o" "sampler") + ("default-menu.o" "default-menu") + ) \ No newline at end of file diff --git a/goal_src/jak2/engine/geometry/bounding-box-h.gc b/goal_src/jak2/engine/geometry/bounding-box-h.gc index e5649ac5c6..fae347adee 100644 --- a/goal_src/jak2/engine/geometry/bounding-box-h.gc +++ b/goal_src/jak2/engine/geometry/bounding-box-h.gc @@ -5,3 +5,52 @@ ;; name in dgo: bounding-box-h ;; dgos: ENGINE, GAME +(deftype bounding-box (structure) + ((min vector :inline :offset-assert 0) + (max vector :inline :offset-assert 16) + ) + :method-count-assert 21 + :size-assert #x20 + :flag-assert #x1500000020 + (:methods + (add-spheres! (_type_ (inline-array sphere) int) int 9) + (add-box! (_type_ bounding-box) int 10) + (add-point! (_type_ vector) none 11) + (intersects-line-segment? (_type_ vector vector) symbol 12) + (set-from-point-offset! (_type_ vector vector) none 13) + (set-from-point-offset-pad! (_type_ vector vector float) int 14) + (set-to-point! (_type_ vector vector float) none 15) + (set-from-sphere! (_type_ sphere) none 16) + (set-from-spheres! (_type_ (inline-array sphere) int) int 17) + (get-bounding-sphere (_type_ vector) vector 18) + (inside-xyz? (bounding-box vector) symbol 19) + (inside-xz? (bounding-box vector) symbol 20) + ) + ) + +(deftype bounding-box4w (structure) + ((min vector4w :inline :offset-assert 0) + (max vector4w :inline :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(deftype bounding-box-both (structure) + ((box bounding-box :inline :offset-assert 0) + (box4w bounding-box4w :inline :offset-assert 32) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + +(deftype bounding-box-array (inline-array-class) + ((data bounding-box :inline :dynamic :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) +(set! (-> bounding-box-array heap-base) (the-as uint 32)) diff --git a/goal_src/jak2/engine/geometry/bounding-box.gc b/goal_src/jak2/engine/geometry/bounding-box.gc index 8de6e2bb84..ede1ad4280 100644 --- a/goal_src/jak2/engine/geometry/bounding-box.gc +++ b/goal_src/jak2/engine/geometry/bounding-box.gc @@ -5,3 +5,295 @@ ;; name in dgo: bounding-box ;; dgos: ENGINE, GAME +(defmethod inside-xyz? bounding-box ((obj bounding-box) (arg0 vector)) + (and (< (-> obj min x) (-> arg0 x)) + (< (-> obj min y) (-> arg0 y)) + (< (-> obj min z) (-> arg0 z)) + (< (-> arg0 x) (-> obj max x)) + (< (-> arg0 y) (-> obj max y)) + (< (-> arg0 z) (-> obj max z)) + ) + ) + +(defmethod inside-xz? bounding-box ((obj bounding-box) (arg0 vector)) + (and (< (-> obj min x) (-> arg0 x)) + (< (-> obj min z) (-> arg0 z)) + (< (-> arg0 x) (-> obj max x)) + (< (-> arg0 z) (-> obj max z)) + ) + ) + +(defun box-vector-enside? ((arg0 bounding-box) (arg1 vector)) + (and (< (-> arg0 min x) (-> arg1 x)) + (< (-> arg0 min y) (-> arg1 y)) + (< (-> arg0 min z) (-> arg1 z)) + (< (-> arg1 x) (-> arg0 max x)) + (< (-> arg1 y) (-> arg0 max y)) + (< (-> arg1 z) (-> arg0 max z)) + ) + ) + +(defun box-vector-inside? ((arg0 bounding-box) (arg1 vector)) + (and (>= (-> arg1 x) (-> arg0 min x)) + (>= (-> arg1 y) (-> arg0 min y)) + (>= (-> arg1 z) (-> arg0 min z)) + (>= (-> arg0 max x) (-> arg1 x)) + (>= (-> arg0 max y) (-> arg1 y)) + (>= (-> arg0 max z) (-> arg1 z)) + ) + ) + +(defmethod set-from-point-offset! bounding-box ((obj bounding-box) (arg0 vector) (arg1 vector)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + ) + (init-vf0-vector) + (.lvf vf3 (&-> arg1 quad)) + (.lvf vf4 (&-> arg0 quad)) + (.add.vf vf5 vf4 vf3) + (.min.vf vf1 vf4 vf5) + (.max.vf vf2 vf4 vf5) + (.mov.vf vf1 vf0 :mask #b1000) + (.mov.vf vf2 vf0 :mask #b1000) + (.svf (&-> obj min quad) vf1) + (.svf (&-> obj max quad) vf2) + 0 + (none) + ) + ) + +(defmethod add-point! bounding-box ((obj bounding-box) (arg0 vector)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (.lvf vf1 (&-> obj min quad)) + (.lvf vf2 (&-> obj max quad)) + (.lvf vf3 (&-> arg0 quad)) + (.min.vf vf1 vf1 vf3) + (.max.vf vf2 vf2 vf3) + (.svf (&-> obj min quad) vf1) + (.svf (&-> obj max quad) vf2) + 0 + (none) + ) + ) + +(defmethod add-box! bounding-box ((obj bounding-box) (arg0 bounding-box)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + ) + (.lvf vf1 (&-> obj min quad)) + (.lvf vf2 (&-> obj max quad)) + (.lvf vf3 (&-> arg0 min quad)) + (.lvf vf4 (&-> arg0 max quad)) + (.min.vf vf1 vf1 vf3) + (.max.vf vf2 vf2 vf4) + (.svf (&-> obj min quad) vf1) + (.svf (&-> obj max quad) vf2) + 0 + ) + ) + +(defmethod set-to-point! bounding-box ((obj bounding-box) (arg0 vector) (arg1 vector) (arg2 float)) + (set! (-> obj min quad) (-> arg0 quad)) + (set! (-> obj max quad) (-> arg0 quad)) + 0 + (none) + ) + +(defmethod set-from-point-offset-pad! bounding-box ((obj bounding-box) (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) + (vf6 :class vf) + ) + (init-vf0-vector) + (.lvf vf4 (&-> arg1 quad)) + (.lvf vf5 (&-> arg0 quad)) + (.mov vf1 arg2) + (.add.vf vf6 vf5 vf4) + (.min.vf vf2 vf5 vf6) + (.max.vf vf3 vf5 vf6) + (.add.x.vf vf3 vf3 vf1 :mask #b111) + (.sub.x.vf vf2 vf2 vf1 :mask #b111) + (.mov.vf vf2 vf0 :mask #b1000) + (.mov.vf vf3 vf0 :mask #b1000) + (.svf (&-> obj min quad) vf2) + (.svf (&-> obj max quad) vf3) + 0 + ) + ) + +(defmethod set-from-sphere! bounding-box ((obj bounding-box) (arg0 sphere)) + (rlet ((vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + ) + (init-vf0-vector) + (.lvf vf1 (&-> arg0 quad)) + (.sub.w.vf vf2 vf1 vf1 :mask #b111) + (.add.w.vf vf3 vf1 vf1 :mask #b111) + (.mov.vf vf2 vf0 :mask #b1000) + (.mov.vf vf3 vf0 :mask #b1000) + (.svf (&-> obj min quad) vf2) + (.svf (&-> obj max quad) vf3) + 0 + (none) + ) + ) + +(defmethod set-from-spheres! bounding-box ((obj bounding-box) (spheres (inline-array sphere)) (count int)) + "Reset box to hold the given spheres. Note: this implementation could be optimized." + ;; This is also unrolled, but does 7 at a time. + (rlet ((vf0 :class vf) + (current-min :class vf) + (current-max :class vf) + (sph-min :class vf) + (sph-max :class vf) + (sph :class vf)) + ;; init constant + (init-vf0-vector) + ;; init min/max. in the case we don't have any spheres, we should return (0,0,0,1) for min/max. + (set! current-min vf0) + (set! current-max vf0) + + (dotimes (i count) + (.lvf sph (-> spheres i)) + (.sub.w.vf sph-min sph sph :mask #b111) + (.add.w.vf sph-max sph sph :mask #b111) + (cond + ((zero? i) + (set! current-min sph-min) + (set! current-max sph-max) + ) + (else + (.min.vf current-min current-min sph-min :mask #b111) + (.max.vf current-max current-max sph-max :mask #b111) + ) + ) + ) + + (.svf (-> obj min) current-min) + (.svf (-> obj max) current-max) + ) + 0 + ) + +(defmethod add-spheres! bounding-box ((obj bounding-box) (spheres (inline-array sphere)) (count int)) + "Add count spheres." + ;; the PS2 implementation is very optimized + ;; It is unrolled and 'software pipelined' to do 4 at a time. + ;; This is slightly less optimized. + (rlet ((current-min :class vf) + (current-max :class vf) + (sph-min :class vf) + (sph-max :class vf) + (sph :class vf)) + + (when (nonzero? count) + ;; load these outside the loop + (.lvf current-min (-> obj min)) + (.lvf current-max (-> obj max)) + + (dotimes (i count) + (.lvf sph (-> spheres i)) + (.sub.w.vf sph-min sph sph :mask #b111) + (.add.w.vf sph-max sph sph :mask #b111) + (.min.vf current-min current-min sph-min :mask #b111) + (.max.vf current-max current-max sph-max :mask #b111) + ) + + (.svf (-> obj min) current-min) + (.svf (-> obj max) current-max) + ) + ) + 0 + ) + +(defmethod get-bounding-sphere bounding-box ((obj bounding-box) (arg0 vector)) + (let* ((a1-2 (vector-! (new 'stack-no-clear 'vector) (-> obj max) (-> obj min))) + (a0-3 (vector-float*! (new 'stack-no-clear 'vector) a1-2 0.5)) + ) + (vector+! arg0 (-> obj min) a0-3) + (set! (-> arg0 w) (vector-length a0-3)) + ) + arg0 + ) + +(deftype liang-barsky-line-clip-params (structure) + ((te float :offset-assert 0) + (tl float :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(defun liang-barsky-line-clipt ((arg0 liang-barsky-line-clip-params) (arg1 float) (arg2 float)) + (cond + ((< 0.0 arg1) + (let ((f0-2 (/ arg2 arg1))) + (if (< (-> arg0 tl) f0-2) + (return #f) + ) + (if (< (-> arg0 te) f0-2) + (set! (-> arg0 te) f0-2) + ) + ) + ) + ((< arg1 0.0) + (let ((f0-5 (/ arg2 arg1))) + (if (< f0-5 (-> arg0 te)) + (return #f) + ) + (if (< f0-5 (-> arg0 tl)) + (set! (-> arg0 tl) f0-5) + ) + ) + ) + (else + (if (< 0.0 arg2) + (return #f) + ) + ) + ) + #t + ) + +(defmethod intersects-line-segment? bounding-box ((obj bounding-box) (arg0 vector) (arg1 vector)) + (let ((f28-0 (- (-> arg1 x) (-> arg0 x))) + (f30-0 (- (-> arg1 z) (-> arg0 z))) + ) + (cond + ((and (= f28-0 0.0) (= f30-0 0.0)) + (let ((f1-2 (-> arg0 x)) + (f0-4 (-> arg0 z)) + ) + (and (>= f1-2 (-> obj min x)) (>= (-> obj max x) f1-2) (>= f0-4 (-> obj min z)) (>= (-> obj max z) f0-4)) + ) + ) + (else + (let ((s4-0 (new 'stack-no-clear 'liang-barsky-line-clip-params))) + (set! (-> s4-0 te) 0.0) + (set! (-> s4-0 tl) 1.0) + (and (liang-barsky-line-clipt s4-0 f28-0 (- (-> obj min x) (-> arg0 x))) + (liang-barsky-line-clipt s4-0 (- f28-0) (- (-> arg0 x) (-> obj max x))) + (liang-barsky-line-clipt s4-0 f30-0 (- (-> obj min z) (-> arg0 z))) + (liang-barsky-line-clipt s4-0 (- f30-0) (- (-> arg0 z) (-> obj max z))) + ) + ) + ) + ) + ) + ) diff --git a/goal_src/jak2/engine/geometry/geometry-h.gc b/goal_src/jak2/engine/geometry/geometry-h.gc index b5b7fcfbb1..cee396e514 100644 --- a/goal_src/jak2/engine/geometry/geometry-h.gc +++ b/goal_src/jak2/engine/geometry/geometry-h.gc @@ -5,3 +5,30 @@ ;; name in dgo: geometry-h ;; dgos: ENGINE, GAME +(deftype curve (structure) + ((cverts (inline-array vector) :offset-assert 0) + (num-cverts int32 :offset-assert 4) + (knots (pointer float) :offset-assert 8) + (num-knots int32 :offset-assert 12) + (length float :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x14 + :flag-assert #x900000014 + ) + +(deftype border-plane (basic) + ((name symbol :offset-assert 4) + (action basic :offset-assert 8) + (slot int8 :offset-assert 12) + (trans vector :inline :offset-assert 16) + (normal vector :inline :offset-assert 32) + ) + :method-count-assert 11 + :size-assert #x30 + :flag-assert #xb00000030 + (:methods + (debug-draw! (_type_) none 9) + (point-past-plane? (_type_ vector) symbol 10) + ) + ) diff --git a/goal_src/jak2/engine/math/euler-h.gc b/goal_src/jak2/engine/math/euler-h.gc index 8a580c224a..aeb55a1327 100644 --- a/goal_src/jak2/engine/math/euler-h.gc +++ b/goal_src/jak2/engine/math/euler-h.gc @@ -5,3 +5,12 @@ ;; name in dgo: euler-h ;; dgos: ENGINE, GAME +(define EulSafe (new 'static 'boxed-array :type int32 0 1 2 0)) +(define EulNext (new 'static 'boxed-array :type int32 1 2 0 1)) + +(deftype euler-angles (vector) + () + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) diff --git a/goal_src/jak2/engine/math/math.gc b/goal_src/jak2/engine/math/math.gc index daded09cf2..8b1fabdf64 100644 --- a/goal_src/jak2/engine/math/math.gc +++ b/goal_src/jak2/engine/math/math.gc @@ -5,3 +5,790 @@ ;; name in dgo: math ;; dgos: ENGINE, GAME +(defun truncate ((arg0 float)) + (the float (the int arg0)) + ) + +(defun floor ((arg0 float)) + (let ((f0-3 (the float (the int arg0)))) + (if (or (>= arg0 0.0) (= arg0 f0-3)) + f0-3 + (+ -1.0 f0-3) + ) + ) + ) + +(defun ceil ((arg0 float)) + (let ((f0-3 (the float (the int arg0)))) + (if (or (>= 0.0 arg0) (= arg0 f0-3)) + f0-3 + (+ 1.0 f0-3) + ) + ) + ) + +(defun integral? ((arg0 float)) + (= (the float (the int arg0)) arg0) + ) + +(defun fractional-part ((arg0 float)) + (- arg0 (the float (the int arg0))) + ) + +(defun sawtooth-wave ((arg0 float)) + (let ((f0-2 (- arg0 (the float (the int arg0))))) + (if (< f0-2 0.0) + (set! f0-2 (+ 1.0 f0-2)) + ) + f0-2 + ) + ) + +(defun triangle-wave ((arg0 float)) + (let* ((f0-1 (* 0.25 (+ -1.0 arg0))) + (f0-3 (- f0-1 (the float (the int f0-1)))) + ) + (if (< f0-3 0.0) + (set! f0-3 (+ 1.0 f0-3)) + ) + (+ -1.0 (fabs (+ -2.0 (* 4.0 f0-3)))) + ) + ) + +(defun log-x-plus-1-order9 ((arg0 float)) + (* arg0 (+ 1.0 + (* arg0 (+ -0.5 + (* arg0 (+ 0.33333334 + (* arg0 (+ -0.25 + (* arg0 (+ 0.2 + (* arg0 (+ -0.16666666 + (* arg0 (+ 0.14285715 + (* arg0 (+ -0.125 + (* 0.11111111 arg0))))))))) + ) + ) + ) + ) + ) + ) + ) + ) + ) + +(defun logf ((arg0 float)) + (let ((v1-1 (the-as int (+ (shr (the-as int arg0) 23) -126))) + (a0-2 (the-as number (logior #x3f000000 (logand (the-as uint #x807fffff) (the-as uint arg0))))) + ) + (when (< (the-as float a0-2) 0.70710677) + (set! a0-2 (+ (the-as float a0-2) (the-as float a0-2))) + (set! v1-1 (the-as int (+ (the-as uint v1-1) -1))) + ) + (let ((f0-5 (+ (the-as float -1.0) (the-as float a0-2)))) + (+ (* f0-5 + (+ 1.0 (* f0-5 + (+ -0.5 (* f0-5 + (+ 0.33333334 (* f0-5 + (+ -0.25 (* f0-5 + (+ 0.2 (* f0-5 + (+ -0.16666666 (* f0-5 + (+ 0.14285715 (* f0-5 + (+ -0.125 (* 0.11111111 f0-5))))))))) + ) + ) + ) + ) + ) + ) + ) + ) + (* 0.6931472 (the float v1-1)) + ) + ) + ) + ) + +(defun log2f ((arg0 float)) + (let ((v1-1 (the-as int (+ (shr (the-as int arg0) 23) -126))) + (a0-2 (the-as number (logior #x3f000000 (logand (the-as uint #x807fffff) (the-as uint arg0))))) + ) + (when (< (the-as float a0-2) 0.70710677) + (set! a0-2 (+ (the-as float a0-2) (the-as float a0-2))) + (set! v1-1 (the-as int (+ (the-as uint v1-1) -1))) + ) + (let* ((f0-5 (+ (the-as float -1.0) (the-as float a0-2))) + (f0-7 (* f0-5 (+ 1.0 + (* f0-5 (+ -0.5 + (* f0-5 (+ 0.33333334 + (* f0-5 (+ -0.25 + (* f0-5 (+ 0.2 + (* f0-5 (+ -0.16666666 + (* f0-5 (+ 0.14285715 + (* f0-5 (+ -0.125 + (* 0.11111111 f0-5))))))))) + ) + ) + ) + ) + ) + ) + ) + ) + ) + ) + (+ (* 1.442695 f0-7) (the float v1-1)) + ) + ) + ) + +(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 pow ((arg0 float) (arg1 float)) + (exp (* arg1 (logf arg0))) + ) + +(defun print-exp ((arg0 float)) + (let* ((f30-1 (floor (/ (logf (fabs arg0)) (logf 10.0)))) + (f0-4 (pow 10.0 f30-1)) + ) + (format #t "~fe~d" (/ arg0 f0-4) (the int f30-1)) + ) + 0 + (none) + ) + +(deftype rgba (uint32) + ((r uint8 :offset 0 :size 8) + (g uint8 :offset 8 :size 8) + (b uint8 :offset 16 :size 8) + (a uint8 :offset 24 :size 8) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype xyzw (uint128) + () + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype xyzwh (uint128) + () + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(defun print-time ((arg0 object) (arg1 time-frame)) + 0 + 0 + 0 + (let* ((f0-1 (* 0.0033333334 (the float arg1))) + (a2-0 (the int (* 0.016666668 f0-1))) + (f0-2 (- f0-1 (* 60.0 (the float a2-0)))) + (a3-0 (the int f0-2)) + (f0-3 (- f0-2 (the float a3-0))) + (t0-0 (the int (* 1000.0 f0-3))) + ) + (format arg0 "~d:~2,'0,d:~3,'0,d" a2-0 a3-0 t0-0) + ) + 0 + (none) + ) + +(defun log2 ((arg0 int)) + (+ (sar (the-as int (the float arg0)) 23) -127) + ) + +(defun seek ((arg0 float) (arg1 float) (arg2 float)) + (let ((f2-0 (- arg1 arg0))) + (cond + ((>= arg2 (fabs f2-0)) + arg1 + ) + ((>= f2-0 0.0) + (+ arg0 arg2) + ) + (else + (- arg0 arg2) + ) + ) + ) + ) + +(defun seek-ease ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float)) + (let ((f2-0 (- arg1 arg0))) + (when (>= arg3 (fabs f2-0)) + (set! arg2 (* arg2 (- 1.0 (/ (- arg3 (fabs f2-0)) arg3)))) + (if (< arg2 arg4) + (set! arg2 arg4) + ) + ) + (cond + ((>= arg2 (fabs f2-0)) + arg1 + ) + ((>= f2-0 0.0) + (+ arg0 arg2) + ) + (else + (- arg0 arg2) + ) + ) + ) + ) + +(defun seek-ease-in-out ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float) (arg5 float) (arg6 float)) + (let ((f2-0 (- arg2 arg0))) + (let ((f4-1 (- arg0 arg1))) + (when (>= arg4 (fabs f4-1)) + (set! arg3 (* arg3 (- 1.0 (/ (- arg4 (fabs f4-1)) arg4)))) + (if (< arg3 arg6) + (set! arg3 arg6) + ) + ) + ) + (when (>= arg5 (fabs f2-0)) + (set! arg3 (* arg3 (- 1.0 (/ (- arg5 (fabs f2-0)) arg5)))) + (if (< arg3 arg6) + (set! arg3 arg6) + ) + ) + (cond + ((>= arg3 (fabs f2-0)) + arg2 + ) + ((>= f2-0 0.0) + (+ arg0 arg3) + ) + (else + (- arg0 arg3) + ) + ) + ) + ) + +(defun lerp ((arg0 float) (arg1 float) (arg2 float)) + (+ arg0 (* arg2 (- arg1 arg0))) + ) + +(defun-debug lerp-scale-old ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float)) + (let ((f0-1 (fmax 0.0 (fmin 1.0 (/ (- arg2 arg3) (- arg4 arg3)))))) + (+ (* (- 1.0 f0-1) arg0) (* f0-1 arg1)) + ) + ) + +(defun lerp-scale ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float)) + ;;(local-vars (f0-2 float)) + (let* (;; (v1-0 #x3f800000) + (f1-0 0.0) + (f0-0 1.0) + (f4-0 arg2) + (f2-0 arg3) + (f3-0 arg4) + (f1-2 (fmin (fmax (/ (- f4-0 f2-0) (- f3-0 f2-0)) f1-0) f0-0)) + (f0-1 (- f0-0 f1-2)) + (f2-3 arg0) + (f3-1 arg1) + ) + (+ (* f0-1 f2-3) (* f1-2 f3-1)) + ;;(.mula.s f0-1 f2-3) + ;;(.madd.s f0-2 f1-2 f3-1) + ) + ;; f0-2 + ) + +(defun lerp-clamp ((arg0 float) (arg1 float) (arg2 float)) + (cond + ((>= 0.0 arg2) + arg0 + ) + ((>= arg2 1.0) + arg1 + ) + (else + (+ (* (- 1.0 arg2) arg0) (* arg2 arg1)) + ) + ) + ) + +(defun seekl ((arg0 int) (arg1 int) (arg2 int)) + (let* ((v1-0 (- arg1 arg0)) + (a3-0 (abs v1-0))) + (cond + ((>= arg2 a3-0) + arg1 + ) + ((>= v1-0 0) + (+ arg0 arg2) + ) + (else + (- arg0 arg2) + ) + ) + ) + ) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; random vu hardware +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;; in the PS2 there is a R register for generating random numbers +;; it is a "32-bit" register, but the upper bits are fixed so it always +;; represents a float in (1, 2). +;; we don't have this register on x86, so we add a special global: *_vu-reg-R_* +(define *_vu-reg-R_* 0) + +(defun rand-vu-init ((seed float)) + "Initialize the VU0 random generator" + ;; (.ctc2.i R arg0) + ;; (.cfc2.i v0 R) + (set! *_vu-reg-R_* + (logior #x3F800000 (logand (the-as int seed) #x007FFFFF)) + ) + (the-as float *_vu-reg-R_*) + ) + +;; this is _almost_ sqrt(2) = 1.414 +(rand-vu-init 1.418091058731079) + +;; rand-vu +(defun rand-vu () + "Get a random number in [0, 1) and advance the random generator." + ;; (.vrget.xyzw vf1) - get current random + (let ((current-random *_vu-reg-R_*)) + ;; here they update the random generate with some junk + ;; for now, we don't do this in OpenGOAL. + ;; (.vsqrty Q vf1) + ;; (.vaddq.x vf2 vf0 Q) ;; you're not allowed to do this! + ;; (.vrxorw vf2) + + ;; and advance + ;; (.vrnext.xyzw vf1) + (let ((x (logand 1 (shr current-random 4))) + (y (logand 1 (shr current-random 22))) + ) + (set! current-random (shl current-random 1)) + (set! current-random (logxor current-random (logxor x y))) + (set! *_vu-reg-R_* (logior #x3f800000 (logand current-random #x7fffff))) + ) + ) + + ;; (.vsubw.xyzw vf1 vf1 vf0) + ;; (.qmfc2.i v0 vf1) + (- (the-as float *_vu-reg-R_*) 1.0) + ) + +;; rand-vu-nostep +(defun rand-vu-nostep () + "Get the number currently in the random generator. + This will be equal to the last call of (rand-vu) + This will not update the random generator" + (- (the-as float *_vu-reg-R_*) 1.0) + ) + +(defun rand-vu-float-range ((arg0 float) (arg1 float)) + (+ arg0 (* (rand-vu) (- arg1 arg0))) + ) + +(defun rand-vu-percent? ((arg0 float)) + (>= arg0 (rand-vu)) + ) + +(defun rand-vu-int-range ((arg0 int) (arg1 int)) + (if (< arg0 arg1) + (set! arg1 (+ arg1 1)) + (set! arg0 (+ arg0 1)) + ) + (let ((f0-4 (rand-vu-float-range (the float arg0) (the float arg1)))) + (if (< f0-4 0.0) + (set! f0-4 (+ -1.0 f0-4)) + ) + (the int f0-4) + ) + ) + +(defun rand-vu-int-count ((arg0 int)) + (the int (* (rand-vu) (the float arg0))) + ) + +(defun rand-vu-int-count-excluding ((arg0 int) (arg1 int)) + (let ((s4-0 0) + (s5-0 0) + ) + (let ((v1-0 1)) + (while (nonzero? arg0) + (+! arg0 -1) + (if (zero? (logand arg1 v1-0)) + (+! s4-0 1) + ) + (set! v1-0 (* v1-0 2)) + ) + ) + (when (> s4-0 0) + (let ((v1-4 (the int (* (rand-vu) (the float s4-0)))) + (a0-1 1) + ) + (until #f + (while (logtest? arg1 a0-1) + (nop!) + (nop!) + (+! s5-0 1) + (set! a0-1 (* a0-1 2)) + ) + (if (zero? v1-4) + (goto cfg-14) + ) + (+! v1-4 -1) + (+! s5-0 1) + (set! a0-1 (* a0-1 2)) + ) + ) + #f + ) + (label cfg-14) + s5-0 + ) + ) + +(defun rand-vu-int-range-exclude ((arg0 int) (arg1 int) (arg2 int)) + (until #f + (let ((v1-0 (rand-vu-int-range arg0 arg1))) + (if (!= v1-0 arg2) + (return v1-0) + ) + ) + ) + (the-as int #f) + ) + +(deftype random-generator (basic) + ((seed uint32 :offset-assert 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(define *random-generator* (new 'global 'random-generator)) + +(set! (-> *random-generator* seed) (the-as uint #x666edd1e)) + +(defmacro sext32-64 (x) + "Sign extend a 32-bit value to 64-bits" + `(sar (shl ,x 32) 32) + ) + +(defun rand-uint31-gen ((gen random-generator)) + "Generate a supposedly random integer. + Note, this might not quite be right. + But the highest bit is always zero, like it says + and it looks kinda random to me." + (let* ((sd (-> gen seed)) + ;; addiu v1, r0, 16807 + ;; mult3 v0, v1, a1 + (prod (imul64 16807 sd)) + ;; mfhi v1 + (hi (shr prod 32)) ;; sign extend this? + (lo (sar (shl prod 32) 32)) + ;; daddu v1, v1, v1 + (v1 (+ hi hi)) + ;; srl a1, v0, 31 + (a1 (logand #xffffffff (shr lo 31))) + ;; or v1, v1, a1 + ;; daddu v0, v0 v1 + (result (+ lo (logior v1 a1))) + ) + (set! result (shr (logand #xffffffff (shl result 1)) 1)) + (set! (-> gen seed) result) + (the uint result) + ) + ) + +(defmacro rand-float-gen (&key (gen *random-generator*)) + "Generate a float from [0, 1)" + `(+ -1.0 (the-as float (logior #x3f800000 (/ (rand-uint31-gen ,gen) 256)))) + ) + +(defun cube-root ((arg0 float)) + (the-as + float + (cond + ((!= arg0 (the-as float 0.0)) + (let* ((v1-0 arg0) + (a1-2 (+ (logand (shr (the-as int v1-0) 23) 255) -127)) + (f0-1 + (the-as + float + (logior (logand (the-as uint #x807fffff) (the-as uint v1-0)) (shl (+ (/ (the-as int a1-2) 3) 127) 23)) + ) + ) + ) + (dotimes (v1-3 6) + (set! f0-1 + (- f0-1 (/ (- (* (* f0-1 f0-1) f0-1) arg0) + (* (* 3.0 f0-1) f0-1) + ) + ) + ) + ) + f0-1 + ) + ) + (else + 0 + ) + ) + ) + ) + +(defun int-noise ((arg0 int)) + (let ((v1-1 (logxor (shl arg0 13) arg0))) + (- 1.0 (* 0.0000000009313226 + (the float (logand #x7fffffff (+ #x5208dd0d (* v1-1 (+ #xc0ae5 (* (* #x3d73 v1-1) v1-1)))))) + ) + ) + ) + ) + +(defun smooth-step ((arg0 float)) + (the-as float (cond + ((>= 0.0 arg0) + 0 + ) + ((>= arg0 1.0) + #x3f800000 + ) + (else + (* arg0 arg0 (+ 3.0 (* -2.0 arg0))) + ) + ) + ) + ) + +(defun smooth-interp ((arg0 float) (arg1 float) (arg2 float) (arg3 float) (arg4 float)) + (+ arg0 (* (- arg1 arg0) (smooth-step (/ (- arg2 arg3) (- arg4 arg3))))) + ) \ No newline at end of file diff --git a/goal_src/jak2/engine/math/matrix-h.gc b/goal_src/jak2/engine/math/matrix-h.gc index 53c0043a3d..9ead40f84c 100644 --- a/goal_src/jak2/engine/math/matrix-h.gc +++ b/goal_src/jak2/engine/math/matrix-h.gc @@ -5,3 +5,50 @@ ;; name in dgo: matrix-h ;; dgos: ENGINE, GAME +(deftype matrix (structure) + ((data float 16 :offset-assert 0) + (vector vector 4 :offset 0) + (quad uint128 4 :offset 0) + (trans vector :inline :offset 48) + ) + :method-count-assert 10 + :size-assert #x40 + :flag-assert #xa00000040 + (:methods + (transform-vectors! (_type_ (inline-array vector) (inline-array vector) int) none 9) + ) + ) + +(deftype matrix3 (structure) + ((data float 12 :offset-assert 0) + (vector vector 3 :offset 0) + (quad uint128 3 :offset 0) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype matrix4h (structure) + ((data int16 16 :offset-assert 0) + (vector4h vector4h 4 :offset 0) + (long int64 4 :offset 0) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(defun matrix-copy! ((arg0 matrix) (arg1 matrix)) + (let ((v1-0 (-> arg1 quad 0)) + (a2-0 (-> arg1 quad 1)) + (a3-0 (-> arg1 quad 2)) + (a1-1 (-> arg1 trans quad)) + ) + (set! (-> arg0 quad 0) v1-0) + (set! (-> arg0 quad 1) a2-0) + (set! (-> arg0 quad 2) a3-0) + (set! (-> arg0 trans quad) a1-1) + ) + arg0 + ) diff --git a/goal_src/jak2/engine/math/matrix.gc b/goal_src/jak2/engine/math/matrix.gc index 40b3ea1365..7a746dc243 100644 --- a/goal_src/jak2/engine/math/matrix.gc +++ b/goal_src/jak2/engine/math/matrix.gc @@ -5,3 +5,1833 @@ ;; name in dgo: matrix ;; dgos: ENGINE, GAME +(defmethod inspect matrix ((obj matrix)) + (format #t "[~8x] matrix~%" obj) + (format #t "~T[~F] [~F] [~F] [~F]~%" (-> obj data 0) (-> obj data 1) (-> obj data 2) (-> obj data 3)) + (format #t "~T[~F] [~F] [~F] [~F]~%" (-> obj data 4) (-> obj data 5) (-> obj data 6) (-> obj data 7)) + (format #t "~T[~F] [~F] [~F] [~F]~%" (-> obj data 8) (-> obj data 9) (-> obj data 10) (-> obj data 11)) + (format #t "~T[~F] [~F] [~F] [~F]~%" (-> obj trans x) (-> obj trans y) (-> obj trans z) (-> obj trans w)) + obj + ) + +(defmethod inspect matrix3 ((obj matrix3)) + (format #t "[~8x] matrix3~%" obj) + (format #t "~T[~F] [~F] [~F]~%" (-> obj data 0) (-> obj data 1) (-> obj data 2)) + (format #t "~T[~F] [~F] [~F]~%" (-> obj data 4) (-> obj data 5) (-> obj data 6)) + (format #t "~T[~F] [~F] [~F]~%" (-> obj data 8) (-> obj data 9) (-> obj data 10)) + obj + ) + +(defun matrix-identity! ((arg0 matrix)) + (set! (-> arg0 quad 0) (the-as uint128 0)) + (set! (-> arg0 quad 1) (the-as uint128 0)) + (set! (-> arg0 quad 2) (the-as uint128 0)) + (set! (-> arg0 trans quad) (the-as uint128 0)) + (let ((f0-0 1.0)) + (set! (-> arg0 trans w) f0-0) + (set! (-> arg0 data 10) f0-0) + (set! (-> arg0 data 5) f0-0) + (set! (-> arg0 data 0) f0-0) + ) + arg0 + ) + +(define *identity-matrix* (matrix-identity! (new 'global 'matrix))) + +(define *hermite-matrix* + (new 'static 'matrix + :data (new 'static 'array float 16 2.0 -2.0 1.0 1.0 -3.0 3.0 -2.0 -1.0 0.0 0.0 1.0 0.0 1.0 0.0 0.0 0.0) + ) + ) + +(defun matrix+! ((arg0 matrix) (arg1 matrix) (arg2 matrix)) + (dotimes (v1-0 16) + (set! (-> arg0 data v1-0) (+ (-> arg1 data v1-0) (-> arg2 data v1-0))) + ) + arg0 + ) + +(defun matrix-! ((arg0 matrix) (arg1 matrix) (arg2 matrix)) + (dotimes (v1-0 16) + (set! (-> arg0 data v1-0) (- (-> arg1 data v1-0) (-> arg2 data v1-0))) + ) + arg0 + ) + +(defun matrix*! ((arg0 matrix) (arg1 matrix) (arg2 matrix)) + (rlet ((acc :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) + (vf19 :class vf) + (vf20 :class vf) + (vf21 :class vf) + ) + (.lvf vf10 (&-> arg1 quad 0)) + (.lvf vf14 (&-> arg2 quad 0)) + (.lvf vf15 (&-> arg2 quad 1)) + (.lvf vf16 (&-> arg2 quad 2)) + (.lvf vf17 (&-> arg2 trans quad)) + (.lvf vf11 (&-> arg1 quad 1)) + (.lvf vf12 (&-> arg1 quad 2)) + (.lvf vf13 (&-> arg1 trans quad)) + (.mul.x.vf acc vf14 vf10) + (.add.mul.y.vf acc vf15 vf10 acc) + (.add.mul.z.vf acc vf16 vf10 acc) + (.add.mul.w.vf vf18 vf17 vf10 acc) + (.mul.x.vf acc vf14 vf11) + (.add.mul.y.vf acc vf15 vf11 acc) + (.add.mul.z.vf acc vf16 vf11 acc) + (.add.mul.w.vf vf19 vf17 vf11 acc) + (.mul.x.vf acc vf14 vf12) + (.add.mul.y.vf acc vf15 vf12 acc) + (.add.mul.z.vf acc vf16 vf12 acc) + (.add.mul.w.vf vf20 vf17 vf12 acc) + (.mul.x.vf acc vf14 vf13) + (.add.mul.y.vf acc vf15 vf13 acc) + (.add.mul.z.vf acc vf16 vf13 acc) + (.add.mul.w.vf vf21 vf17 vf13 acc) + (.svf (&-> arg0 quad 0) vf18) + (.svf (&-> arg0 quad 1) vf19) + (.svf (&-> arg0 quad 2) vf20) + (.svf (&-> arg0 trans quad) vf21) + arg0 + ) + ) + +(defun matrixp*! ((arg0 matrix) (arg1 matrix) (arg2 matrix)) + (let ((s5-0 (new 'stack-no-clear 'matrix))) + (set! (-> s5-0 quad 0) (the-as uint128 0)) + (set! (-> s5-0 quad 1) (the-as uint128 0)) + (set! (-> s5-0 quad 2) (the-as uint128 0)) + (set! (-> s5-0 trans quad) (the-as uint128 0)) + (matrix*! s5-0 arg1 arg2) + (set! (-> arg0 quad 0) (-> s5-0 quad 0)) + (set! (-> arg0 quad 1) (-> s5-0 quad 1)) + (set! (-> arg0 quad 2) (-> s5-0 quad 2)) + (set! (-> arg0 trans quad) (-> s5-0 trans quad)) + ) + arg0 + ) + +(defun vector-matrix*! ((arg0 vector) (arg1 vector) (arg2 matrix)) + (rlet ((acc :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + ) + (.lvf vf1 (&-> arg2 quad 0)) + (.lvf vf2 (&-> arg2 quad 1)) + (.lvf vf3 (&-> arg2 quad 2)) + (.lvf vf4 (&-> arg2 trans quad)) + (.lvf vf5 (&-> arg1 quad)) + (.mul.x.vf acc vf1 vf5) + (.add.mul.y.vf acc vf2 vf5 acc) + (.add.mul.z.vf acc vf3 vf5 acc) + (.add.mul.w.vf vf5 vf4 vf5 acc) + (.svf (&-> arg0 quad) vf5) + arg0 + ) + ) + +(defun vector-rotate*! ((arg0 vector) (arg1 vector) (arg2 matrix)) + (rlet ((acc :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf5 :class vf) + ) + (nop!) + (nop!) + (.lvf vf5 (&-> arg1 quad)) + (nop!) + (.lvf vf1 (&-> arg2 quad 0)) + (nop!) + (.lvf vf2 (&-> arg2 quad 1)) + (.mul.x.vf acc vf1 vf5) + (.lvf vf3 (&-> arg2 quad 2)) + (.add.mul.y.vf acc vf2 vf5 acc) + (.lvf vf4 (&-> arg2 trans quad)) + (.add.mul.z.vf vf5 vf3 vf5 acc) + (nop!) + (nop!) + (.svf (&-> arg0 quad) vf5) + arg0 + ) + ) + +(defun vector3s-matrix*! ((arg0 vector3s) (arg1 vector3s) (arg2 matrix)) + (let ((s5-0 (new-stack-vector0))) + (set-vector! s5-0 (-> arg1 x) (-> arg1 y) (-> arg1 z) 1.0) + (vector-matrix*! s5-0 s5-0 arg2) + (set! (-> arg0 x) (-> s5-0 x)) + (set! (-> arg0 y) (-> s5-0 y)) + (set! (-> arg0 z) (-> s5-0 z)) + ) + arg0 + ) + +(defun vector3s-rotate*! ((arg0 vector3s) (arg1 vector3s) (arg2 matrix)) + (let ((s5-0 (new-stack-vector0))) + (set-vector! s5-0 (-> arg1 x) (-> arg1 y) (-> arg1 z) 1.0) + (vector-rotate*! s5-0 s5-0 arg2) + (set! (-> arg0 x) (-> s5-0 x)) + (set! (-> arg0 y) (-> s5-0 y)) + (set! (-> arg0 z) (-> s5-0 z)) + ) + arg0 + ) + +(defun matrix-transpose! ((arg0 matrix) (arg1 matrix)) + (local-vars + (v1-0 uint128) + (v1-1 uint128) + (v1-2 uint128) + (a1-1 uint128) + (a2-1 uint128) + (t0-1 uint128) + ) + (nop!) + (nop!) + (let ((t0-0 (-> arg1 quad 0))) + (nop!) + (let ((t1-0 (-> arg1 quad 1))) + (nop!) + (let ((a2-0 (-> arg1 quad 2))) + (.pextlw v1-0 t1-0 t0-0) + (let ((a3-0 (-> arg1 trans quad))) + (.pextuw a1-1 t1-0 t0-0) + (.pextlw t0-1 a3-0 a2-0) + (.pextuw a2-1 a3-0 a2-0) + ) + ) + ) + ) + (let ((a3-1 (make-u128 t0-1 v1-0))) + (.pcpyud v1-1 v1-0 t0-1) + (set! (-> arg0 quad 0) (the-as uint128 a3-1)) + ) + (let ((a3-2 (make-u128 a2-1 a1-1))) + (set! (-> arg0 quad 1) v1-1) + (.pcpyud v1-2 a1-1 a2-1) + (set! (-> arg0 quad 2) (the-as uint128 a3-2)) + ) + (nop!) + (set! (-> arg0 trans quad) v1-2) + arg0 + ) + +(defun matrix-inverse-of-rot-trans! ((arg0 matrix) (arg1 matrix)) + (rlet ((acc :class vf) + (vf0 :class vf) + (vf1 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf8 :class vf) + ) + (init-vf0-vector) + (matrix-transpose! arg0 arg1) + (.lvf vf1 (&-> arg0 quad 0)) + (.lvf vf2 (&-> arg0 quad 1)) + (.lvf vf3 (&-> arg0 quad 2)) + (.sub.vf vf1 vf1 vf1 :mask #b1000) + (.sub.vf vf2 vf2 vf2 :mask #b1000) + (.sub.vf vf3 vf3 vf3 :mask #b1000) + (.lvf vf8 (&-> arg1 trans quad)) + (.mul.x.vf acc vf1 vf8) + (.add.mul.y.vf acc vf2 vf8 acc) + (.add.mul.z.vf vf4 vf3 vf8 acc) + (.sub.vf vf4 vf0 vf4) + (.mov.vf vf4 vf0 :mask #b1000) + (.svf (&-> arg0 quad 0) vf1) + (.svf (&-> arg0 quad 1) vf2) + (.svf (&-> arg0 quad 2) vf3) + (.svf (&-> arg0 trans quad) vf4) + arg0 + ) + ) + +(defun matrix-4x4-inverse! ((arg0 matrix) (arg1 matrix)) + (rlet ((acc :class vf) + (Q :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) + (vf19 :class vf) + (vf2 :class vf) + (vf20 :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) + (vf30 :class vf) + (vf31 :class vf) + (vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + (vf8 :class vf) + (vf9 :class vf) + ) + ;; ADDED: the original implementation does math on vectors where some values are + ;; uninitialized. It doesn't use the result, so there's no problem, but this + ;; may cause strange slowdowns on x86 where doing math on NaNs can be extremely slow. + ;; ideally we should find a better solution. + (.xor.vf vf26 vf26 vf26) + (.xor.vf vf27 vf27 vf27) + (.xor.vf vf28 vf28 vf28) + (.xor.vf vf29 vf29 vf29) + (.xor.vf vf30 vf30 vf30) + (.xor.vf vf31 vf31 vf31) + (.xor.vf vf16 vf16 vf16) + (.xor.vf vf17 vf17 vf17) + (.xor.vf vf18 vf18 vf18) + (.xor.vf vf23 vf23 vf23) + (.xor.vf vf19 vf19 vf19) + (init-vf0-vector) + (nop!) + (nop!) + (.lvf vf23 (&-> arg1 quad 0)) + (nop!) + (.lvf vf24 (&-> arg1 quad 1)) + (nop!) + (.lvf vf25 (&-> arg1 quad 2)) + (nop!) + (.lvf vf1 (&-> arg1 trans quad)) + (.mul.x.vf vf7 vf24 vf23) + (nop!) + (.mul.y.vf vf8 vf24 vf23) + (nop!) + (.mul.z.vf vf9 vf24 vf23) + (nop!) + (.mul.x.vf vf10 vf25 vf23) + (nop!) + (.mul.y.vf vf11 vf25 vf23) + (nop!) + (.mul.z.vf vf12 vf25 vf23) + (nop!) + (.mul.x.vf vf13 vf25 vf24) + (nop!) + (.mul.y.vf vf14 vf25 vf24) + (nop!) + (.mul.z.vf vf15 vf25 vf24) + (nop!) + (.mul.z.vf vf26 vf7 vf25 :mask #b10) + (nop!) + (.mul.z.vf vf27 vf11 vf24 :mask #b1) + (nop!) + (.mul.y.vf vf28 vf9 vf25 :mask #b1) + (nop!) + (.mul.z.vf vf29 vf14 vf23 :mask #b1) + (nop!) + (.mul.z.vf vf30 vf8 vf25 :mask #b1) + (nop!) + (.mul.y.vf vf31 vf7 vf25 :mask #b100) + (nop!) + (.add.y.vf vf16 vf27 vf26 :mask #b1) + (nop!) + (.sub.vf vf1 vf0 vf1) + (nop!) + (.add.x.vf vf17 vf29 vf30 :mask #b1) + (nop!) + (.sub.z.vf vf18 vf28 vf31 :mask #b1) + (nop!) + (.sub.y.vf vf23 vf14 vf15 :mask #b100) + (nop!) + (.sub.z.vf vf26 vf15 vf13 :mask #b1) + (nop!) + (.sub.x.vf vf29 vf13 vf14 :mask #b10) + (nop!) + (.sub.vf vf19 vf16 vf17 :mask #b1) + (nop!) + (.sub.z.vf vf24 vf12 vf11 :mask #b10) + (nop!) + (.sub.x.vf vf27 vf10 vf12 :mask #b100) + (nop!) + (.sub.y.vf vf30 vf11 vf10 :mask #b1) + (nop!) + (.add.vf vf20 vf19 vf18 :mask #b1) + (nop!) + (.sub.y.vf vf25 vf8 vf9 :mask #b100) + (nop!) + (.sub.z.vf vf28 vf9 vf7 :mask #b1) + (nop!) + (.sub.x.vf vf31 vf7 vf8 :mask #b10) + (nop!) + (.div.vf Q vf0 vf20 :fsf #b11 :ftf #b0) + (nop!) + ;; (.sub.w.vf vf3 vf3 vf3 :mask #b1000) + (nop!) + ;; (.sub.w.vf vf4 vf4 vf4 :mask #b1000) + (nop!) + ;; (.sub.w.vf vf5 vf5 vf5 :mask #b1000) + (nop!) + (.mov.vf vf6 vf0 :mask #b1000) + (nop!) + (.wait.vf) + (nop!) + (.add.vf vf2 vf0 Q :mask #b1) + (nop!) + (.add.x.vf vf2 vf0 vf2 :mask #b111) + (nop!) + (.mul.z.vf vf3 vf2 vf23 :mask #b1) + (nop!) + (.mul.x.vf vf4 vf2 vf26 :mask #b1) + (nop!) + (.mul.y.vf vf5 vf2 vf29 :mask #b1) + (nop!) + (.mul.y.vf vf3 vf2 vf24 :mask #b10) + (nop!) + (.mul.z.vf vf4 vf2 vf27 :mask #b10) + (nop!) + (.mul.x.vf vf5 vf2 vf30 :mask #b10) + (nop!) + (.mul.z.vf vf3 vf2 vf25 :mask #b100) + (nop!) + (.mul.x.vf vf4 vf2 vf28 :mask #b100) + (nop!) + (.mul.y.vf vf5 vf2 vf31 :mask #b100) + (nop!) + (.mul.x.vf acc vf3 vf1) + (.svf (&-> arg0 quad 0) vf3) + (.add.mul.y.vf acc vf4 vf1 acc) + (.svf (&-> arg0 quad 1) vf4) + (.add.mul.z.vf vf6 vf5 vf1 acc :mask #b111) + (.svf (&-> arg0 quad 2) vf5) + (nop!) + (.svf (&-> arg0 trans quad) vf6) + arg0 + ) + ) + +(defun matrix-translate! ((arg0 matrix) (arg1 vector)) + (matrix-identity! arg0) + (set! (-> arg0 trans x) (-> arg1 x)) + (set! (-> arg0 trans y) (-> arg1 y)) + (set! (-> arg0 trans z) (-> arg1 z)) + arg0 + ) + +(defun matrix-translate+! ((arg0 matrix) (arg1 matrix) (arg2 vector)) + (set! (-> arg0 trans x) (+ (-> arg1 trans x) (-> arg2 x))) + (set! (-> arg0 trans y) (+ (-> arg1 trans y) (-> arg2 y))) + (set! (-> arg0 trans z) (+ (-> arg1 trans z) (-> arg2 z))) + (when (!= arg0 arg1) + (set! (-> arg0 quad 0) (-> arg1 quad 0)) + (set! (-> arg0 quad 1) (-> arg1 quad 1)) + (set! (-> arg0 quad 2) (-> arg1 quad 2)) + ) + arg0 + ) + +(defun matrix-scale! ((arg0 matrix) (arg1 vector)) + (set! (-> arg0 quad 0) (the-as uint128 0)) + (set! (-> arg0 quad 1) (the-as uint128 0)) + (set! (-> arg0 quad 2) (the-as uint128 0)) + (set! (-> arg0 trans quad) (the-as uint128 0)) + (set! (-> arg0 data 0) (-> arg1 x)) + (set! (-> arg0 data 5) (-> arg1 y)) + (set! (-> arg0 data 10) (-> arg1 z)) + (set! (-> arg0 trans w) 1.0) + arg0 + ) + +(defun scale-matrix! ((arg0 matrix) (arg1 vector) (arg2 matrix)) + (rlet ((vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + (vf8 :class vf) + ) + (.lvf vf4 (&-> arg1 quad)) + (.lvf vf5 (&-> arg2 quad 0)) + (.lvf vf6 (&-> arg2 quad 1)) + (.lvf vf7 (&-> arg2 quad 2)) + (.lvf vf8 (&-> arg2 trans quad)) + (.mul.x.vf vf5 vf5 vf4) + (.mul.y.vf vf6 vf6 vf4) + (.mul.z.vf vf7 vf7 vf4) + (.mul.w.vf vf8 vf8 vf4) + (.svf (&-> arg0 quad 0) vf5) + (.svf (&-> arg0 quad 1) vf6) + (.svf (&-> arg0 quad 2) vf7) + (.svf (&-> arg0 trans quad) vf8) + arg0 + ) + ) + +(defun matrix-inv-scale! ((arg0 matrix) (arg1 vector)) + (set! (-> arg0 quad 0) (the-as uint128 0)) + (set! (-> arg0 quad 1) (the-as uint128 0)) + (set! (-> arg0 quad 2) (the-as uint128 0)) + (set! (-> arg0 trans quad) (the-as uint128 0)) + (set! (-> arg0 data 0) (/ 1.0 (-> arg1 x))) + (set! (-> arg0 data 5) (/ 1.0 (-> arg1 y))) + (set! (-> arg0 data 10) (/ 1.0 (-> arg1 z))) + (set! (-> arg0 trans w) 1.0) + arg0 + ) + +(defun column-scale-matrix! ((arg0 matrix) (arg1 vector) (arg2 matrix)) + (rlet ((vf4 :class vf) + (vf5 :class vf) + (vf6 :class vf) + (vf7 :class vf) + (vf8 :class vf) + ) + (.lvf vf4 (&-> arg1 quad)) + (.lvf vf5 (&-> arg2 quad 0)) + (.lvf vf6 (&-> arg2 quad 1)) + (.lvf vf7 (&-> arg2 quad 2)) + (.lvf vf8 (&-> arg2 trans quad)) + (.mul.vf vf5 vf5 vf4) + (.mul.vf vf6 vf6 vf4) + (.mul.vf vf7 vf7 vf4) + (.mul.vf vf8 vf8 vf4) + (.svf (&-> arg0 quad 0) vf5) + (.svf (&-> arg0 quad 1) vf6) + (.svf (&-> arg0 quad 2) vf7) + (.svf (&-> arg0 trans quad) vf8) + arg0 + ) + ) + +(defun matrix-rotate-x! ((arg0 matrix) (arg1 float)) + (let ((f30-0 (sin arg1)) + (f0-0 (cos arg1)) + ) + (set! (-> arg0 quad 0) (the-as uint128 0)) + (set! (-> arg0 quad 1) (the-as uint128 0)) + (set! (-> arg0 quad 2) (the-as uint128 0)) + (set! (-> arg0 trans quad) (the-as uint128 0)) + (set! (-> arg0 data 0) 1.0) + (set! (-> arg0 data 5) f0-0) + (set! (-> arg0 data 6) f30-0) + (set! (-> arg0 data 9) (- f30-0)) + (set! (-> arg0 data 10) f0-0) + ) + (set! (-> arg0 trans w) 1.0) + arg0 + ) + +(defun matrix-rotate-y! ((arg0 matrix) (arg1 float)) + (let ((f30-0 (sin arg1)) + (f0-0 (cos arg1)) + ) + (set! (-> arg0 quad 0) (the-as uint128 0)) + (set! (-> arg0 quad 1) (the-as uint128 0)) + (set! (-> arg0 quad 2) (the-as uint128 0)) + (set! (-> arg0 trans quad) (the-as uint128 0)) + (set! (-> arg0 data 0) f0-0) + (set! (-> arg0 data 2) (- f30-0)) + (set! (-> arg0 data 5) 1.0) + (set! (-> arg0 data 8) f30-0) + (set! (-> arg0 data 10) f0-0) + ) + (set! (-> arg0 trans w) 1.0) + arg0 + ) + +(defun matrix-rotate-z! ((arg0 matrix) (arg1 float)) + (let ((f30-0 (sin arg1)) + (f0-0 (cos arg1)) + ) + (set! (-> arg0 quad 0) (the-as uint128 0)) + (set! (-> arg0 quad 1) (the-as uint128 0)) + (set! (-> arg0 quad 2) (the-as uint128 0)) + (set! (-> arg0 trans quad) (the-as uint128 0)) + (set! (-> arg0 data 0) f0-0) + (set! (-> arg0 data 1) f30-0) + (set! (-> arg0 data 4) (- f30-0)) + (set! (-> arg0 data 5) f0-0) + ) + (set! (-> arg0 data 10) 1.0) + (set! (-> arg0 trans w) 1.0) + arg0 + ) + +(defun matrix-rotate-zyx! ((arg0 matrix) (arg1 vector)) + (let ((gp-0 (new 'stack-no-clear 'matrix))) + (set! (-> gp-0 quad 0) (the-as uint128 0)) + (set! (-> gp-0 quad 1) (the-as uint128 0)) + (set! (-> gp-0 quad 2) (the-as uint128 0)) + (set! (-> gp-0 trans quad) (the-as uint128 0)) + (let ((s5-0 (new 'stack-no-clear 'matrix))) + (set! (-> s5-0 quad 0) (the-as uint128 0)) + (set! (-> s5-0 quad 1) (the-as uint128 0)) + (set! (-> s5-0 quad 2) (the-as uint128 0)) + (set! (-> s5-0 trans quad) (the-as uint128 0)) + (matrix-rotate-x! arg0 (-> arg1 x)) + (matrix-rotate-y! gp-0 (-> arg1 y)) + (matrix*! s5-0 gp-0 arg0) + (matrix-rotate-z! gp-0 (-> arg1 z)) + (matrix*! arg0 gp-0 s5-0) + ) + ) + arg0 + ) + +(defun-debug matrix-rotate-xyz-2! ((arg0 matrix) (arg1 vector)) + (let ((gp-0 (new 'stack-no-clear 'matrix)) + (s5-0 (new 'stack-no-clear 'matrix)) + ) + (matrix-rotate-z! arg0 (-> arg1 z)) + (matrix-rotate-y! gp-0 (-> arg1 y)) + (matrix*! s5-0 gp-0 arg0) + (matrix-rotate-x! gp-0 (-> arg1 x)) + (matrix*! arg0 gp-0 s5-0) + ) + arg0 + ) + +(defun matrix-rotate-xyz! ((arg0 matrix) (arg1 vector)) + (rlet ((vf0 :class vf)) + (init-vf0-vector) + (let ((s4-0 (new 'stack-no-clear 'vector)) + (s5-0 (new 'stack-no-clear 'vector)) + ) + (vector-sincos! s4-0 s5-0 arg1) + (let ((f2-0 (-> s4-0 x)) + (f5-0 (-> s4-0 y)) + (f3-0 (-> s4-0 z)) + (f0-0 (-> s5-0 x)) + (f1-0 (-> s5-0 y)) + ) + (let ((f4-0 (-> s5-0 z))) + (set! (-> arg0 data 0) (* f1-0 f4-0)) + (set! (-> arg0 data 1) (* f1-0 f3-0)) + (set! (-> arg0 data 2) (- f5-0)) + (set! (-> arg0 data 3) 0.0) + (let ((f6-4 (* f2-0 f5-0)) + (f5-1 (* f0-0 f5-0)) + ) + (set! (-> arg0 data 4) (- (* f6-4 f4-0) (* f0-0 f3-0))) + (set! (-> arg0 data 5) (+ (* f6-4 f3-0) (* f0-0 f4-0))) + (set! (-> arg0 data 6) (* f2-0 f1-0)) + (set! (-> arg0 data 7) 0.0) + (set! (-> arg0 data 8) (+ (* f2-0 f3-0) (* f5-1 f4-0))) + (set! (-> arg0 data 9) (- (* f5-1 f3-0) (* f2-0 f4-0))) + ) + ) + (set! (-> arg0 data 10) (* f0-0 f1-0)) + ) + ) + (set! (-> arg0 data 11) 0.0) + (.svf (&-> arg0 trans quad) vf0) + arg0 + ) + ) + +(defun matrix-rotate-zxy! ((arg0 matrix) (arg1 vector)) + (let ((gp-0 (new 'stack-no-clear 'matrix))) + (set! (-> gp-0 quad 0) (the-as uint128 0)) + (set! (-> gp-0 quad 1) (the-as uint128 0)) + (set! (-> gp-0 quad 2) (the-as uint128 0)) + (set! (-> gp-0 trans quad) (the-as uint128 0)) + (let ((s5-0 (new 'stack-no-clear 'matrix))) + (set! (-> s5-0 quad 0) (the-as uint128 0)) + (set! (-> s5-0 quad 1) (the-as uint128 0)) + (set! (-> s5-0 quad 2) (the-as uint128 0)) + (set! (-> s5-0 trans quad) (the-as uint128 0)) + (matrix-rotate-y! arg0 (-> arg1 y)) + (matrix-rotate-x! gp-0 (-> arg1 x)) + (matrix*! s5-0 gp-0 arg0) + (matrix-rotate-z! gp-0 (-> arg1 z)) + (matrix*! arg0 gp-0 s5-0) + ) + ) + arg0 + ) + +(defun matrix-rotate-yxz! ((arg0 matrix) (arg1 vector)) + (let ((gp-0 (new 'stack-no-clear 'matrix))) + (set! (-> gp-0 quad 0) (the-as uint128 0)) + (set! (-> gp-0 quad 1) (the-as uint128 0)) + (set! (-> gp-0 quad 2) (the-as uint128 0)) + (set! (-> gp-0 trans quad) (the-as uint128 0)) + (let ((s5-0 (new 'stack-no-clear 'matrix))) + (set! (-> s5-0 quad 0) (the-as uint128 0)) + (set! (-> s5-0 quad 1) (the-as uint128 0)) + (set! (-> s5-0 quad 2) (the-as uint128 0)) + (set! (-> s5-0 trans quad) (the-as uint128 0)) + (matrix-rotate-z! arg0 (-> arg1 z)) + (matrix-rotate-x! gp-0 (-> arg1 x)) + (matrix*! s5-0 gp-0 arg0) + (matrix-rotate-y! gp-0 (-> arg1 y)) + (matrix*! arg0 gp-0 s5-0) + ) + ) + arg0 + ) + +(defun matrix-rotate-yzx! ((arg0 matrix) (arg1 vector)) + (let ((gp-0 (new 'stack-no-clear 'matrix))) + (set! (-> gp-0 quad 0) (the-as uint128 0)) + (set! (-> gp-0 quad 1) (the-as uint128 0)) + (set! (-> gp-0 quad 2) (the-as uint128 0)) + (set! (-> gp-0 trans quad) (the-as uint128 0)) + (let ((s5-0 (new 'stack-no-clear 'matrix))) + (set! (-> s5-0 quad 0) (the-as uint128 0)) + (set! (-> s5-0 quad 1) (the-as uint128 0)) + (set! (-> s5-0 quad 2) (the-as uint128 0)) + (set! (-> s5-0 trans quad) (the-as uint128 0)) + (matrix-rotate-z! arg0 (-> arg1 x)) + (matrix-rotate-x! gp-0 (-> arg1 z)) + (matrix*! s5-0 gp-0 arg0) + (matrix-rotate-y! gp-0 (-> arg1 y)) + (matrix*! arg0 gp-0 s5-0) + ) + ) + arg0 + ) + +(defun matrix-rotate-yxy! ((arg0 matrix) (arg1 vector)) + (let ((a2-0 (new 'stack-no-clear 'vector)) + (s5-0 (new 'stack-no-clear 'vector)) + (s4-0 (new 'stack-no-clear 'vector)) + ) + (set-vector! a2-0 (-> arg1 x) (- (-> arg1 y) (-> arg1 z)) (-> arg1 z) 1.0) + (vector-sincos! s5-0 s4-0 a2-0) + (let ((f1-1 (-> s4-0 y)) + (f0-5 (-> s5-0 y)) + (f2-0 (-> s4-0 x)) + (f5-0 (-> s5-0 x)) + (f3-0 (-> s4-0 z)) + (f4-0 (-> s5-0 z)) + ) + (set! (-> arg0 data 0) (- (* f1-1 f3-0) (* f0-5 f2-0 f4-0))) + (set! (-> arg0 data 1) (* f0-5 f5-0)) + (set! (-> arg0 data 2) (- (+ (* f1-1 f4-0) (* f0-5 f2-0 f3-0)))) + (set! (-> arg0 data 3) 0.0) + (set! (-> arg0 data 4) (* f5-0 f4-0)) + (set! (-> arg0 data 5) f2-0) + (set! (-> arg0 data 6) (* f5-0 f3-0)) + (set! (-> arg0 data 7) 0.0) + (set! (-> arg0 data 8) (+ (* f0-5 f3-0) (* f1-1 f2-0 f4-0))) + (set! (-> arg0 data 9) (- (* f1-1 f5-0))) + (set! (-> arg0 data 10) (- (* f1-1 f2-0 f3-0) (* f0-5 f4-0))) + ) + ) + (set! (-> arg0 data 11) 0.0) + (set! (-> arg0 trans x) 0.0) + (set! (-> arg0 trans y) 0.0) + (set! (-> arg0 trans z) 0.0) + (set! (-> arg0 trans w) 1.0) + arg0 + ) + +(defun matrix-rotate-yx! ((arg0 matrix) (arg1 float) (arg2 float)) + (matrix-rotate-y! arg0 arg1) + (let ((t9-1 matrix-rotate-x!) + (a0-2 (new 'stack-no-clear 'matrix)) + ) + (set! (-> a0-2 quad 0) (the-as uint128 0)) + (set! (-> a0-2 quad 1) (the-as uint128 0)) + (set! (-> a0-2 quad 2) (the-as uint128 0)) + (set! (-> a0-2 trans quad) (the-as uint128 0)) + (let ((a1-2 (t9-1 a0-2 arg2))) + (matrix*! arg0 a1-2 arg0) + ) + ) + arg0 + ) + +(defun matrix-axis-sin-cos! ((dst matrix) (axis vector) (s float) (c float)) + "Create an axis-angle rotation matrix. But given the sin/cos of the angle." + ;;or v0, a0, r0 + ;;or v1, a1, r0 + ;;mtc1 f0, a2 + ;;mtc1 f1, a3 + ;;sll r0, r0, 0 + + ;; input scramble: + ;; - v0 = dst + ;; - v1 = axis + ;; - f0 = sine + ;; - f1 = cosine + (rlet ((vf5 :class vf) ;; vf5.x will be sine, vf5.w will be -cosine + (vf6 :class vf) ;; vf6.x will be cosine + (vf1 :class vf) ;; vector. + (vf0 :class vf) + (vf2 :class vf) + (vf3 :class vf) + (vf4 :class vf) + (vf11 :class vf) + (vf7 :class vf) + (vf8 :class vf) + (vf9 :class vf) + (vf10 :class vf) + (a1 :class i128 :type uint128) + (r0 :class i128 :type uint128)) ;; will be used for zero check. + ;; initialize constant vectors + (init-vf0-vector) + (.xor.p r0 r0 r0) + + ;; this is an overly complicated check to see if xyz = 0. + + (let ((a0 65535) ;; ori a0, r0, 65535 + (v1 (-> axis quad))) ;; lq v1, 0(v1) + + ;; this a0 constant has ffff in the upper 16 bits to mask out w, later on. + ;; dsll32 a0, a0, 16 + (set! a0 (shl a0 48)) ;; a0 = ffff'0000'0000'0000 + + ;;mfc1 a1, f1 + ;;qmtc2.i vf6, a1 + (.mov vf6 c) ;; will set vf6.x to cosine. + + ;;pceqw a1, v1, r0 + ;; compare for equality with zero. + ;; this will set 32-bits for each component. + (.pceqw a1 v1 r0) + + ;; so we pack: [upper64, w0?16, z0?16, y0?16, x0?16] + (.ppach a1 r0 a1) + + ;;qmtc2.i vf1, v1 + (.mov vf1 v1) ;; should be quad move! + + ;;or v1, a1, a0 + ;; make it seem like w is zero. If x,y,z = 0, but w != 0, we want + ;; it to act like zero. + (let ((xyz-zero (logior a0 (the uint a1)))) + ;;mfc1 a0, f0 + ;;qmtc2.i vf5, a0 + (.mov vf5 s) + + ;;daddiu v1, v1, 1 + ;; if all is zero, this will overflow and give us 0. + (+! xyz-zero 1) + + ;;vsubx.w vf5, vf0, vf6 + (.sub.x.vf vf5 vf0 vf6 :mask #b1000) + + ;;beq v1, r0, L15 + ;;vaddx.y vf5, vf0, vf6 + (.add.x.vf vf5 vf0 vf6 :mask #b0010) + (when-goto (zero? xyz-zero) zero-case) + ) + ) + + ;; Nonzero case: + ;; vsubw.w vf2, vf0, vf0 + ;; vsubw.w vf3, vf0, vf0 + ;; vsubw.w vf4, vf0, vf0 + (.xor.vf vf2 vf2 vf2) + (.xor.vf vf3 vf3 vf3) + (.xor.vf vf4 vf4 vf4) + + ;;vmulx.xyz vf11, vf1, vf5 + (.mul.x.vf vf11 vf1 vf5 :mask #b0111) + + ;;vaddy.x vf7, vf0, vf5 + (.add.y.vf vf7 vf0 vf5 :mask #b0001) + + ;;vaddy.y vf8, vf0, vf5 + (.add.y.vf vf8 vf0 vf5 :mask #b0010) + + ;;vaddy.z vf9, vf0, vf5 + (.add.y.vf vf9 vf0 vf5 :mask #b0100) + + ;;vmulw.xyz vf10, vf1, vf5 + (.mul.w.vf vf10 vf1 vf5 :mask #b0111) + + ;;vsubz.y vf7, vf0, vf11 + (.sub.z.vf vf7 vf0 vf11 :mask #b0010) + + ;;vaddy.z vf7, vf0, vf11 + (.add.y.vf vf7 vf0 vf11 :mask #b0100) + + ;;vaddz.x vf8, vf0, vf11 + (.add.z.vf vf8 vf0 vf11 :mask #b0001) + + ;;vsubx.z vf8, vf0, vf11 + (.sub.x.vf vf8 vf0 vf11 :mask #b0100) + + ;;vmulx.xyz vf2, vf10, vf1 + (.mul.x.vf vf2 vf10 vf1 :mask #b0111) + + ;;vmuly.xyz vf3, vf10, vf1 + (.mul.y.vf vf3 vf10 vf1 :mask #b0111) + + ;;vmulz.xyz vf4, vf10, vf1 + (.mul.z.vf vf4 vf10 vf1 :mask #b0111) + + ;;vsuby.x vf9, vf0, vf11 + (.sub.y.vf vf9 vf0 vf11 :mask #b0001) + + ;;vaddx.y vf9, vf0, vf11 + (.add.x.vf vf9 vf0 vf11 :mask #b0010) + + ;;vadd.xyz vf2, vf2, vf7 + (.add.vf vf2 vf2 vf7 :mask #b0111) + + ;;vadd.xyz vf3, vf3, vf8 + (.add.vf vf3 vf3 vf8 :mask #b0111) + + ;;vadd.xyz vf4, vf4, vf9 + (.add.vf vf4 vf4 vf9 :mask #b0111) + + ;;sqc2 vf2, 0(v0) + ;;sqc2 vf3, 16(v0) + ;;sqc2 vf0, 48(v0) + ;;sqc2 vf4, 32(v0) + (.svf (-> dst vector 0) vf2) + (.svf (-> dst vector 1) vf3) + (.svf (-> dst vector 3) vf0) + (.svf (-> dst vector 2) vf4) + (goto end) + (label zero-case) + ;; overly clever way to set identity matrix + ;;lui v1, 16256 + ;;sqc2 vf0, 48(v0) + ;;pcpyld v1, r0, v1 + ;;mfc1 r0, f31 + ;;prot3w a0, v1 + ;;mfc1 r0, f31 + ;;prot3w a1, a0 + ;;sq v1, 0(v0) + ;;sll r0, r0, 0 + ;;sq a0, 32(v0) + ;;sll r0, r0, 0 + ;;sq a1, 16(v0) + (matrix-identity! dst) + (label end) + ) + dst + ) + +(defun matrix-axis-angle! ((dst matrix) (axis vector) (angle-deg float)) + "Create an axis-angle rotation matrix." + (matrix-axis-sin-cos! dst axis (sin angle-deg) (cos angle-deg)) + (none) + ) + +;; definition for function matrix-lerp! +(defun matrix-lerp! ((arg0 matrix) (arg1 matrix) (arg2 matrix) (arg3 float)) + (rlet ((vf1 :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) + ) + (.mov vf9 arg3) + (.lvf vf1 (&-> arg1 quad 0)) + (.lvf vf2 (&-> arg1 quad 1)) + (.lvf vf3 (&-> arg1 quad 2)) + (.lvf vf4 (&-> arg1 trans quad)) + (.lvf vf5 (&-> arg2 quad 0)) + (.lvf vf6 (&-> arg2 quad 1)) + (.lvf vf7 (&-> arg2 quad 2)) + (.lvf vf8 (&-> arg2 trans quad)) + (.sub.vf vf5 vf5 vf1) + (.sub.vf vf6 vf6 vf2) + (.sub.vf vf7 vf7 vf3) + (.sub.vf vf8 vf8 vf4) + (.mul.x.vf vf5 vf5 vf9) + (.mul.x.vf vf6 vf6 vf9) + (.mul.x.vf vf7 vf7 vf9) + (.mul.x.vf vf8 vf8 vf9) + (.add.vf vf1 vf1 vf5) + (.add.vf vf2 vf2 vf6) + (.add.vf vf3 vf3 vf7) + (.add.vf vf4 vf4 vf8) + (.svf (&-> arg0 quad 0) vf1) + (.svf (&-> arg0 quad 1) vf2) + (.svf (&-> arg0 quad 2) vf3) + (.svf (&-> arg0 trans quad) vf4) + arg0 + ) + ) + +;; definition for function matrix-3x3-determinant +(defun matrix-3x3-determinant ((arg0 matrix)) + (let ((f8-0 (-> arg0 data 0)) + (f1-0 (-> arg0 data 1)) + (f4-0 (-> arg0 data 2)) + (f2-0 (-> arg0 data 4)) + (f5-0 (-> arg0 data 5)) + (f9-0 (-> arg0 data 6)) + (f3-0 (-> arg0 data 8)) + (f6-0 (-> arg0 data 9)) + (f0-0 (-> arg0 data 10)) + ) + (- (+ (* f8-0 f5-0 f0-0) (* f1-0 f9-0 f3-0) (* f4-0 f2-0 f6-0)) + (+ (* f8-0 f9-0 f6-0) (* f4-0 f5-0 f3-0) (* f1-0 f2-0 f0-0)) + ) + ) + ) + +(defun matrix3-determinant ((arg0 matrix)) + (local-vars (v0-0 float)) + (rlet ((acc :class vf) + (vf10 :class vf) + (vf11 :class vf) + (vf12 :class vf) + (vf13 :class vf) + ) + (.lvf vf11 (&-> arg0 quad 1)) + (.lvf vf12 (&-> arg0 quad 2)) + (.lvf vf10 (&-> arg0 quad 0)) + (.outer.product.a.vf acc vf11 vf12) + (.outer.product.b.vf vf13 vf12 vf11 acc) + (.mul.vf vf13 vf13 vf10 :mask #b111) + (.add.y.vf vf13 vf13 vf13 :mask #b1) + (.add.z.vf vf13 vf13 vf13 :mask #b1) + (.mov v0-0 vf13) + v0-0 + ) + ) + +(defun matrix-3x3-inverse! ((arg0 matrix) (arg1 matrix)) + (let ((f0-0 (matrix-3x3-determinant arg1))) + (set! (-> arg0 data 0) + (/ (- (* (-> arg1 data 5) (-> arg1 data 10)) (* (-> arg1 data 6) (-> arg1 data 9))) f0-0) + ) + (set! (-> arg0 data 4) + (/ (- (* (-> arg1 data 6) (-> arg1 data 8)) (* (-> arg1 data 4) (-> arg1 data 10))) f0-0) + ) + (set! (-> arg0 data 8) + (/ (- (* (-> arg1 data 4) (-> arg1 data 9)) (* (-> arg1 data 5) (-> arg1 data 8))) f0-0) + ) + (set! (-> arg0 data 1) + (/ (- (* (-> arg1 data 9) (-> arg1 data 2)) (* (-> arg1 data 10) (-> arg1 data 1))) f0-0) + ) + (set! (-> arg0 data 5) + (/ (- (* (-> arg1 data 10) (-> arg1 data 0)) (* (-> arg1 data 8) (-> arg1 data 2))) f0-0) + ) + (set! (-> arg0 data 9) + (/ (- (* (-> arg1 data 8) (-> arg1 data 1)) (* (-> arg1 data 9) (-> arg1 data 0))) f0-0) + ) + (set! (-> arg0 data 2) + (/ (- (* (-> arg1 data 1) (-> arg1 data 6)) (* (-> arg1 data 2) (-> arg1 data 5))) f0-0) + ) + (set! (-> arg0 data 6) + (/ (- (* (-> arg1 data 2) (-> arg1 data 4)) (* (-> arg1 data 0) (-> arg1 data 6))) f0-0) + ) + (set! (-> arg0 data 10) + (/ (- (* (-> arg1 data 0) (-> arg1 data 5)) (* (-> arg1 data 1) (-> arg1 data 4))) f0-0) + ) + ) + arg0 + ) + +(defun matrix-3x3-inverse-transpose! ((arg0 matrix) (arg1 matrix)) + (let ((f0-0 (matrix-3x3-determinant arg1))) + (set! (-> arg0 data 0) + (/ (- (* (-> arg1 data 5) (-> arg1 data 10)) (* (-> arg1 data 6) (-> arg1 data 9))) f0-0) + ) + (set! (-> arg0 data 1) + (/ (- (* (-> arg1 data 6) (-> arg1 data 8)) (* (-> arg1 data 4) (-> arg1 data 10))) f0-0) + ) + (set! (-> arg0 data 2) + (/ (- (* (-> arg1 data 4) (-> arg1 data 9)) (* (-> arg1 data 5) (-> arg1 data 8))) f0-0) + ) + (set! (-> arg0 data 4) + (/ (- (* (-> arg1 data 9) (-> arg1 data 2)) (* (-> arg1 data 10) (-> arg1 data 1))) f0-0) + ) + (set! (-> arg0 data 5) + (/ (- (* (-> arg1 data 10) (-> arg1 data 0)) (* (-> arg1 data 8) (-> arg1 data 2))) f0-0) + ) + (set! (-> arg0 data 6) + (/ (- (* (-> arg1 data 8) (-> arg1 data 1)) (* (-> arg1 data 9) (-> arg1 data 0))) f0-0) + ) + (set! (-> arg0 data 8) + (/ (- (* (-> arg1 data 1) (-> arg1 data 6)) (* (-> arg1 data 2) (-> arg1 data 5))) f0-0) + ) + (set! (-> arg0 data 9) + (/ (- (* (-> arg1 data 2) (-> arg1 data 4)) (* (-> arg1 data 0) (-> arg1 data 6))) f0-0) + ) + (set! (-> arg0 data 10) + (/ (- (* (-> arg1 data 0) (-> arg1 data 5)) (* (-> arg1 data 1) (-> arg1 data 4))) f0-0) + ) + ) + arg0 + ) + +(defun matrix3-inverse-transpose! ((arg0 matrix) (arg1 matrix)) + (rlet ((acc :class vf) + (Q :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) + ) + (init-vf0-vector) + ;; added to make the right most column always zero. + ;; it seems like they didn't care about these values + ;; but this makes the test repeatable, and there + ;; really could be anything here. This function is unused anyway + (.xor.vf vf13 vf13 vf13) + (.xor.vf vf14 vf14 vf14) + (.xor.vf vf15 vf15 vf15) + (.lvf vf10 (&-> arg1 quad 0)) + (.lvf vf11 (&-> arg1 quad 1)) + (.lvf vf12 (&-> arg1 quad 2)) + (.outer.product.a.vf acc vf11 vf12) + (.outer.product.b.vf vf13 vf12 vf11 acc) + (.outer.product.a.vf acc vf12 vf10) + (.outer.product.b.vf vf14 vf10 vf12 acc) + (.mul.vf vf1 vf10 vf13 :mask #b111) + (.outer.product.a.vf acc vf10 vf11) + (.outer.product.b.vf vf15 vf11 vf10 acc) + (.nop.vf) + (.add.y.vf vf1 vf1 vf1 :mask #b1) + (.nop.vf) + (.nop.vf) + (.nop.vf) + (.add.z.vf vf1 vf1 vf1 :mask #b1) + (.nop.vf) + (.nop.vf) + (.nop.vf) + (.div.vf Q vf0 vf1 :fsf #b11 :ftf #b0) + (.wait.vf) + (.mul.vf vf13 vf13 Q) + (.mul.vf vf14 vf14 Q) + (.mul.vf vf15 vf15 Q) + (.nop.vf) + (.nop.vf) + (.svf (&-> arg0 quad 0) vf13) + (.svf (&-> arg0 quad 1) vf14) + (.svf (&-> arg0 quad 2) vf15) + arg0 + ) + ) + +#| +unused?? +(defun matrix-3x3-normalize! ((arg0 matrix) (arg1 matrix)) + (local-vars (f0-1 float) (f0-2 float)) + (rlet ((acc :class vf) + (Q :class vf) + (vf0 :class vf) + (vf10 :class vf) + (vf11 :class vf) + (vf12 :class vf) + (vf13 :class vf) + (vf14 :class vf) + (vf15 :class vf) + (vf16 :class vf) + ) + (init-vf0-vector) + (let ((f2-0 (-> arg1 data 0)) + (f0-0 (-> arg1 data 1)) + (f1-0 (-> arg1 data 2)) + (v1-0 #x3f800000) + ) + (.lvf vf10 (&-> arg1 quad 0)) + (.mula.s f2-0 f2-0) + (.lvf vf11 (&-> arg1 quad 1)) + (let ((f2-1 (gpr->fpr v1-0))) + (.lvf vf12 (&-> arg1 quad 2)) + (.madda.s f0-0 f0-0) + (.sub.w.vf vf13 vf0 vf0 :mask #b1000) + (.madd.s f0-1 f1-0 f1-0) + (.sub.w.vf vf14 vf0 vf0 :mask #b1000) + (.rsqrt.s f0-2 f2-1 f0-1) + ) + ) + (.sub.w.vf vf15 vf0 vf0 :mask #b1000) + (let ((v1-1 f0-2)) + (.mov vf16 v1-1) + ) + (.mul.x.vf vf13 vf10 vf16 :mask #b111) + (.outer.product.a.vf acc vf11 vf13) + (.outer.product.b.vf vf14 vf13 vf11 acc) + (.outer.product.a.vf acc vf13 vf14) + (.outer.product.b.vf vf14 vf14 vf13 acc) + (.mul.vf vf16 vf14 vf14 :mask #b111) + (.mul.x.vf acc vf0 vf16 :mask #b1000) + (.add.mul.y.vf acc vf0 vf16 acc :mask #b1000) + (.add.mul.z.vf vf16 vf0 vf16 acc :mask #b1000) + (.isqrt.vf Q vf0 vf16 :fsf #b11 :ftf #b11) + (.wait.vf) + (.mul.vf vf14 vf14 Q :mask #b111) + (.outer.product.a.vf acc vf13 vf14) + (.outer.product.b.vf vf15 vf14 vf13 acc) + (.svf (&-> arg0 quad 0) vf13) + (.svf (&-> arg0 quad 1) vf14) + (.svf (&-> arg0 quad 2) vf15) + arg0 + ) + ) + |# + +;; definition for function matrix-4x4-determinant +(defun matrix-4x4-determinant ((arg0 matrix)) + (let ((f15-0 (-> arg0 data 0)) + (f14-0 (-> arg0 data 1)) + (f10-0 (-> arg0 data 2)) + (f2-0 (-> arg0 data 3)) + (f9-0 (-> arg0 data 4)) + (f6-0 (-> arg0 data 5)) + (f3-0 (-> arg0 data 6)) + (f11-0 (-> arg0 data 7)) + (f5-0 (-> arg0 data 8)) + (f1-0 (-> arg0 data 9)) + (f8-0 (-> arg0 data 10)) + (f13-0 (-> arg0 data 11)) + (f0-0 (-> arg0 trans x)) + (f7-0 (-> arg0 trans y)) + (f4-0 (-> arg0 trans z)) + (f12-0 (-> arg0 trans w)) + ) + (- (+ (* f15-0 f6-0 f8-0 f12-0) + (* f15-0 f3-0 f13-0 f7-0) + (* f15-0 f11-0 f1-0 f4-0) + (* f14-0 f9-0 f13-0 f4-0) + (* f14-0 f3-0 f5-0 f4-0) + (* f14-0 f11-0 f8-0 f0-0) + (* f10-0 f9-0 f1-0 f12-0) + (* f10-0 f6-0 f13-0 f0-0) + (* f10-0 f11-0 f5-0 f7-0) + (* f2-0 f9-0 f1-0 f4-0) + (* f2-0 f6-0 f8-0 f0-0) + (* f2-0 f3-0 f5-0 f7-0) + ) + (+ (* f15-0 f6-0 f13-0 f4-0) + (* f15-0 f3-0 f1-0 f12-0) + (* f15-0 f11-0 f8-0 f7-0) + (* f14-0 f9-0 f8-0 f12-0) + (* f14-0 f3-0 f13-0 f0-0) + (* f14-0 f11-0 f5-0 f4-0) + (* f10-0 f9-0 f13-0 f7-0) + (* f10-0 f6-0 f5-0 f12-0) + (* f10-0 f11-0 f1-0 f0-0) + (* f2-0 f9-0 f8-0 f7-0) + (* f2-0 f6-0 f5-0 f4-0) + (* f2-0 f3-0 f1-0 f0-0) + ) + ) + ) + ) + +;; definition for function matrix-4x4-inverse-transpose! +(defun matrix-4x4-inverse-transpose! ((arg0 matrix) (arg1 matrix)) + (let ((f0-0 (matrix-4x4-determinant arg1))) + (let ((f9-0 (-> arg1 data 5)) + (f2-0 (-> arg1 data 6)) + (f5-0 (-> arg1 data 7)) + (f3-0 (-> arg1 data 9)) + (f6-0 (-> arg1 data 10)) + (f10-0 (-> arg1 data 11)) + (f4-0 (-> arg1 trans y)) + (f7-0 (-> arg1 trans z)) + (f1-0 (-> arg1 trans w)) + ) + (set! (-> arg0 data 0) (/ (- (+ (* f9-0 f6-0 f1-0) (* f2-0 f10-0 f4-0) (* f5-0 f3-0 f7-0)) + (+ (* f9-0 f10-0 f7-0) (* f5-0 f6-0 f4-0) (* f2-0 f3-0 f1-0)) + ) + f0-0 + ) + ) + ) + (let ((f9-2 (-> arg1 data 4)) + (f2-2 (-> arg1 data 6)) + (f5-2 (-> arg1 data 7)) + (f3-1 (-> arg1 data 8)) + (f6-1 (-> arg1 data 10)) + (f10-1 (-> arg1 data 11)) + (f4-3 (-> arg1 trans x)) + (f7-2 (-> arg1 trans z)) + (f1-6 (-> arg1 trans w)) + ) + (set! (-> arg0 data 1) (- (/ (- (+ (* f9-2 f6-1 f1-6) (* f2-2 f10-1 f4-3) (* f5-2 f3-1 f7-2)) + (+ (* f9-2 f10-1 f7-2) (* f5-2 f6-1 f4-3) (* f2-2 f3-1 f1-6)) + ) + f0-0 + ) + ) + ) + ) + (let ((f9-4 (-> arg1 data 4)) + (f2-4 (-> arg1 data 5)) + (f5-4 (-> arg1 data 7)) + (f3-2 (-> arg1 data 8)) + (f6-2 (-> arg1 data 9)) + (f10-2 (-> arg1 data 11)) + (f4-6 (-> arg1 trans x)) + (f7-4 (-> arg1 trans y)) + (f1-13 (-> arg1 trans w)) + ) + (set! (-> arg0 data 2) (/ (- (+ (* f9-4 f6-2 f1-13) (* f2-4 f10-2 f4-6) (* f5-4 f3-2 f7-4)) + (+ (* f9-4 f10-2 f7-4) (* f5-4 f6-2 f4-6) (* f2-4 f3-2 f1-13)) + ) + f0-0 + ) + ) + ) + (let ((f9-6 (-> arg1 data 4)) + (f2-6 (-> arg1 data 5)) + (f5-6 (-> arg1 data 6)) + (f3-3 (-> arg1 data 8)) + (f6-3 (-> arg1 data 9)) + (f10-3 (-> arg1 data 10)) + (f4-9 (-> arg1 trans x)) + (f7-6 (-> arg1 trans y)) + (f1-19 (-> arg1 trans z)) + ) + (set! (-> arg0 data 3) (- (/ (- (+ (* f9-6 f6-3 f1-19) (* f2-6 f10-3 f4-9) (* f5-6 f3-3 f7-6)) + (+ (* f9-6 f10-3 f7-6) (* f5-6 f6-3 f4-9) (* f2-6 f3-3 f1-19)) + ) + f0-0 + ) + ) + ) + ) + (let ((f9-8 (-> arg1 data 1)) + (f2-8 (-> arg1 data 2)) + (f5-8 (-> arg1 data 3)) + (f3-4 (-> arg1 data 9)) + (f6-4 (-> arg1 data 10)) + (f10-4 (-> arg1 data 11)) + (f4-12 (-> arg1 trans y)) + (f7-8 (-> arg1 trans z)) + (f1-26 (-> arg1 trans w)) + ) + (set! (-> arg0 data 4) (- (/ (- (+ (* f9-8 f6-4 f1-26) (* f2-8 f10-4 f4-12) (* f5-8 f3-4 f7-8)) + (+ (* f9-8 f10-4 f7-8) (* f5-8 f6-4 f4-12) (* f2-8 f3-4 f1-26)) + ) + f0-0 + ) + ) + ) + ) + (let ((f9-10 (-> arg1 data 0)) + (f2-10 (-> arg1 data 2)) + (f5-10 (-> arg1 data 3)) + (f3-5 (-> arg1 data 8)) + (f6-5 (-> arg1 data 10)) + (f10-5 (-> arg1 data 11)) + (f4-15 (-> arg1 trans x)) + (f7-10 (-> arg1 trans z)) + (f1-33 (-> arg1 trans w)) + ) + (set! (-> arg0 data 5) (/ (- (+ (* f9-10 f6-5 f1-33) (* f2-10 f10-5 f4-15) (* f5-10 f3-5 f7-10)) + (+ (* f9-10 f10-5 f7-10) (* f5-10 f6-5 f4-15) (* f2-10 f3-5 f1-33)) + ) + f0-0 + ) + ) + ) + (let ((f9-12 (-> arg1 data 0)) + (f2-12 (-> arg1 data 1)) + (f5-12 (-> arg1 data 3)) + (f3-6 (-> arg1 data 8)) + (f6-6 (-> arg1 data 9)) + (f10-6 (-> arg1 data 11)) + (f4-18 (-> arg1 trans x)) + (f7-12 (-> arg1 trans y)) + (f1-39 (-> arg1 trans w)) + ) + (set! (-> arg0 data 6) (- (/ (- (+ (* f9-12 f6-6 f1-39) (* f2-12 f10-6 f4-18) (* f5-12 f3-6 f7-12)) + (+ (* f9-12 f10-6 f7-12) (* f5-12 f6-6 f4-18) (* f2-12 f3-6 f1-39)) + ) + f0-0 + ) + ) + ) + ) + (let ((f9-14 (-> arg1 data 0)) + (f2-14 (-> arg1 data 1)) + (f5-14 (-> arg1 data 2)) + (f3-7 (-> arg1 data 8)) + (f6-7 (-> arg1 data 9)) + (f10-7 (-> arg1 data 10)) + (f4-21 (-> arg1 trans x)) + (f7-14 (-> arg1 trans y)) + (f1-46 (-> arg1 trans z)) + ) + (set! (-> arg0 data 7) (/ (- (+ (* f9-14 f6-7 f1-46) (* f2-14 f10-7 f4-21) (* f5-14 f3-7 f7-14)) + (+ (* f9-14 f10-7 f7-14) (* f5-14 f6-7 f4-21) (* f2-14 f3-7 f1-46)) + ) + f0-0 + ) + ) + ) + (let ((f9-16 (-> arg1 data 1)) + (f2-16 (-> arg1 data 2)) + (f5-16 (-> arg1 data 3)) + (f3-8 (-> arg1 data 5)) + (f6-8 (-> arg1 data 6)) + (f10-8 (-> arg1 data 7)) + (f4-24 (-> arg1 trans y)) + (f7-16 (-> arg1 trans z)) + (f1-52 (-> arg1 trans w)) + ) + (set! (-> arg0 data 8) (/ (- (+ (* f9-16 f6-8 f1-52) (* f2-16 f10-8 f4-24) (* f5-16 f3-8 f7-16)) + (+ (* f9-16 f10-8 f7-16) (* f5-16 f6-8 f4-24) (* f2-16 f3-8 f1-52)) + ) + f0-0 + ) + ) + ) + (let ((f9-18 (-> arg1 data 0)) + (f2-18 (-> arg1 data 2)) + (f5-18 (-> arg1 data 3)) + (f3-9 (-> arg1 data 4)) + (f6-9 (-> arg1 data 6)) + (f10-9 (-> arg1 data 7)) + (f4-27 (-> arg1 trans x)) + (f7-18 (-> arg1 trans z)) + (f1-58 (-> arg1 trans w)) + ) + (set! (-> arg0 data 9) (- (/ (- (+ (* f9-18 f6-9 f1-58) (* f2-18 f10-9 f4-27) (* f5-18 f3-9 f7-18)) + (+ (* f9-18 f10-9 f7-18) (* f5-18 f6-9 f4-27) (* f2-18 f3-9 f1-58)) + ) + f0-0 + ) + ) + ) + ) + (let ((f9-20 (-> arg1 data 0)) + (f2-20 (-> arg1 data 1)) + (f5-20 (-> arg1 data 3)) + (f3-10 (-> arg1 data 4)) + (f6-10 (-> arg1 data 5)) + (f10-10 (-> arg1 data 7)) + (f4-30 (-> arg1 trans x)) + (f7-20 (-> arg1 trans y)) + (f1-65 (-> arg1 trans w)) + ) + (set! (-> arg0 data 10) (/ (- (+ (* f9-20 f6-10 f1-65) (* f2-20 f10-10 f4-30) (* f5-20 f3-10 f7-20)) + (+ (* f9-20 f10-10 f7-20) (* f5-20 f6-10 f4-30) (* f2-20 f3-10 f1-65)) + ) + f0-0 + ) + ) + ) + (let ((f9-22 (-> arg1 data 0)) + (f2-22 (-> arg1 data 1)) + (f5-22 (-> arg1 data 2)) + (f3-11 (-> arg1 data 4)) + (f6-11 (-> arg1 data 5)) + (f10-11 (-> arg1 data 6)) + (f4-33 (-> arg1 trans x)) + (f7-22 (-> arg1 trans y)) + (f1-71 (-> arg1 trans z)) + ) + (set! (-> arg0 data 11) (- (/ (- (+ (* f9-22 f6-11 f1-71) (* f2-22 f10-11 f4-33) (* f5-22 f3-11 f7-22)) + (+ (* f9-22 f10-11 f7-22) (* f5-22 f6-11 f4-33) (* f2-22 f3-11 f1-71)) + ) + f0-0 + ) + ) + ) + ) + (let ((f9-24 (-> arg1 data 1)) + (f2-24 (-> arg1 data 2)) + (f5-24 (-> arg1 data 3)) + (f3-12 (-> arg1 data 5)) + (f6-12 (-> arg1 data 6)) + (f10-12 (-> arg1 data 7)) + (f4-36 (-> arg1 data 9)) + (f7-24 (-> arg1 data 10)) + (f1-78 (-> arg1 data 11)) + ) + (set! (-> arg0 trans x) (- (/ (- (+ (* f9-24 f6-12 f1-78) (* f2-24 f10-12 f4-36) (* f5-24 f3-12 f7-24)) + (+ (* f9-24 f10-12 f7-24) (* f5-24 f6-12 f4-36) (* f2-24 f3-12 f1-78)) + ) + f0-0 + ) + ) + ) + ) + (let ((f9-26 (-> arg1 data 0)) + (f2-26 (-> arg1 data 2)) + (f5-26 (-> arg1 data 3)) + (f3-13 (-> arg1 data 4)) + (f6-13 (-> arg1 data 6)) + (f10-13 (-> arg1 data 7)) + (f4-39 (-> arg1 data 8)) + (f7-26 (-> arg1 data 10)) + (f1-85 (-> arg1 data 11)) + ) + (set! (-> arg0 trans y) (/ (- (+ (* f9-26 f6-13 f1-85) (* f2-26 f10-13 f4-39) (* f5-26 f3-13 f7-26)) + (+ (* f9-26 f10-13 f7-26) (* f5-26 f6-13 f4-39) (* f2-26 f3-13 f1-85)) + ) + f0-0 + ) + ) + ) + (let ((f9-28 (-> arg1 data 0)) + (f2-28 (-> arg1 data 1)) + (f5-28 (-> arg1 data 3)) + (f3-14 (-> arg1 data 4)) + (f6-14 (-> arg1 data 5)) + (f10-14 (-> arg1 data 7)) + (f4-42 (-> arg1 data 8)) + (f7-28 (-> arg1 data 9)) + (f1-91 (-> arg1 data 11)) + ) + (set! (-> arg0 trans z) (- (/ (- (+ (* f9-28 f6-14 f1-91) (* f2-28 f10-14 f4-42) (* f5-28 f3-14 f7-28)) + (+ (* f9-28 f10-14 f7-28) (* f5-28 f6-14 f4-42) (* f2-28 f3-14 f1-91)) + ) + f0-0 + ) + ) + ) + ) + (let ((f8-60 (-> arg1 data 0)) + (f1-98 (-> arg1 data 1)) + (f5-30 (-> arg1 data 2)) + (f2-30 (-> arg1 data 4)) + (f6-15 (-> arg1 data 5)) + (f9-30 (-> arg1 data 6)) + (f4-45 (-> arg1 data 8)) + (f7-30 (-> arg1 data 9)) + (f3-15 (-> arg1 data 10)) + ) + (set! (-> arg0 trans w) (/ (- (+ (* f8-60 f6-15 f3-15) (* f1-98 f9-30 f4-45) (* f5-30 f2-30 f7-30)) + (+ (* f8-60 f9-30 f7-30) (* f5-30 f6-15 f4-45) (* f1-98 f2-30 f3-15)) + ) + f0-0 + ) + ) + ) + ) + arg0 + ) + +(defun matrix-y-angle ((arg0 matrix)) + (let ((v1-0 (&-> arg0 data 8))) + (atan (-> v1-0 0) (-> v1-0 2)) + ) + ) + +(defun matrix->trans ((arg0 matrix) (arg1 vector)) + (rlet ((Q :class vf) + (vf0 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (.lvf vf2 (&-> arg0 trans quad)) + (.div.vf Q vf0 vf2 :fsf #b11 :ftf #b11) + (.wait.vf) + (.mul.vf vf2 vf2 Q :mask #b111) + (.nop.vf) + (.nop.vf) + (.mov.vf vf2 vf0 :mask #b1000) + (.svf (&-> arg1 quad) vf2) + arg1 + ) + ) + +(defun matrix<-trans ((arg0 matrix) (arg1 vector)) + (set! (-> arg0 trans quad) (-> arg1 quad)) + arg0 + ) + +(defun matrix->scale ((arg0 matrix) (arg1 vector)) + (set! (-> arg1 x) (vector-length (the-as vector (-> arg0 data)))) + (set! (-> arg1 y) (vector-length (the-as vector (&-> arg0 data 4)))) + (set! (-> arg1 z) (vector-length (the-as vector (&-> arg0 data 8)))) + (set! (-> arg1 w) 1.0) + arg1 + ) + +(defun matrix<-scale ((arg0 matrix) (arg1 vector)) + (vector-normalize! (the-as vector (-> arg0 data)) (-> arg1 x)) + (vector-normalize! (the-as vector (&-> arg0 data 4)) (-> arg1 y)) + (vector-normalize! (the-as vector (&-> arg0 data 8)) (-> arg1 z)) + arg0 + ) + +(defun matrix->quat ((arg0 matrix) (arg1 quaternion)) + (let ((s5-0 (new 'stack-no-clear 'matrix))) + (let* ((a2-0 arg0) + (v1-0 (-> a2-0 quad 0)) + (a0-1 (-> a2-0 quad 1)) + (a1-1 (-> a2-0 quad 2)) + (a2-1 (-> a2-0 trans quad)) + ) + (set! (-> s5-0 quad 0) v1-0) + (set! (-> s5-0 quad 1) a0-1) + (set! (-> s5-0 quad 2) a1-1) + (set! (-> s5-0 trans quad) a2-1) + ) + (vector-reset! (-> s5-0 trans)) + (vector-normalize! (the-as vector (-> s5-0 data)) 1.0) + (vector-normalize! (the-as vector (&-> s5-0 data 4)) 1.0) + (vector-normalize! (the-as vector (&-> s5-0 data 8)) 1.0) + (matrix->quaternion arg1 s5-0) + ) + ) + +(defun matrix<-quat ((arg0 matrix) (arg1 quaternion)) + (let ((s5-0 (matrix->scale arg0 (new 'stack-no-clear 'vector))) + (s4-1 (quaternion->matrix (new 'stack-no-clear 'matrix) arg1)) + ) + (vector-normalize-copy! (the-as vector (-> arg0 data)) (the-as vector (-> s4-1 data)) (-> s5-0 x)) + (vector-normalize-copy! (the-as vector (&-> arg0 data 4)) (the-as vector (&-> s4-1 data 4)) (-> s5-0 y)) + (vector-normalize-copy! (the-as vector (&-> arg0 data 8)) (the-as vector (&-> s4-1 data 8)) (-> s5-0 z)) + ) + (set! (-> arg0 data 3) 0.0) + (set! (-> arg0 data 7) 0.0) + (set! (-> arg0 data 11) 0.0) + arg0 + ) + +(defun matrix->transformq ((arg0 transformq) (arg1 matrix)) + (rlet ((Q :class vf) + (vf0 :class vf) + (vf2 :class vf) + ) + (init-vf0-vector) + (.lvf vf2 (&-> arg1 trans quad)) + (.div.vf Q vf0 vf2 :fsf #b11 :ftf #b11) + (.wait.vf) + (.mul.vf vf2 vf2 Q :mask #b111) + (.nop.vf) + (.nop.vf) + (.mov.vf vf2 vf0 :mask #b1000) + (.svf (&-> arg0 trans quad) vf2) + (let ((s4-0 (new 'stack-no-clear 'matrix))) + (let* ((a2-0 arg1) + (v1-0 (-> a2-0 quad 0)) + (a0-1 (-> a2-0 quad 1)) + (a1-1 (-> a2-0 quad 2)) + (a2-1 (-> a2-0 trans quad)) + ) + (set! (-> s4-0 quad 0) v1-0) + (set! (-> s4-0 quad 1) a0-1) + (set! (-> s4-0 quad 2) a1-1) + (set! (-> s4-0 trans quad) a2-1) + ) + (vector-normalize! (the-as vector (-> s4-0 data)) 1.0) + (vector-normalize! (the-as vector (&-> s4-0 data 4)) 1.0) + (vector-normalize! (the-as vector (&-> s4-0 data 8)) 1.0) + (vector-cross! + (the-as vector (&-> s4-0 data 8)) + (the-as vector (-> s4-0 data)) + (the-as vector (&-> s4-0 data 4)) + ) + (vector-cross! + (the-as vector (&-> s4-0 data 4)) + (the-as vector (&-> s4-0 data 8)) + (the-as vector (-> s4-0 data)) + ) + (matrix->quaternion (the-as quaternion (-> arg0 rot)) s4-0) + ) + (set-vector! + (-> arg0 scale) + (vector-length (the-as vector (-> arg1 data))) + (vector-length (the-as vector (&-> arg1 data 4))) + (vector-length (the-as vector (&-> arg1 data 8))) + 1.0 + ) + arg0 + ) + ) + +(defmethod transform-vectors! matrix ((obj _type_) (dst (inline-array vector)) (src (inline-array vector)) (count int)) + "Transform many vectors. This acts like w = 1, even if it isn't. The value of w is copied." + (rlet ((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) + (acc :class vf) + (v1 :type int) + ) + (init-vf0-vector) + + ;; blez a3, L3 + (when-goto (<= count 0) end) + + ;; lqc2 vf1, 0(a0) + (.lvf vf1 (-> obj vector 0)) + + ;; lqc2 vf2, 16(a0) + (.lvf vf2 (-> obj vector 1)) + + ;; lqc2 vf3, 32(a0) + (.lvf vf3 (-> obj vector 2)) + + ;; lqc2 vf4, 48(a0) + (.lvf vf4 (-> obj vector 3)) + + ;; lqc2 vf5, 0(a2) + (.lvf vf5 (-> src 0)) + + ;; lqc2 vf6, 16(a2) + (.lvf vf6 (-> src 1)) + + (label loop-top) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + ;;vmulaw.xyzw acc, vf4, vf0 + (.mul.w.vf acc vf4 vf0) + + ;; lqc2 vf7, 32(a2) + (.lvf vf7 (-> src 2)) + + ;;vmaddax.xyzw acc, vf1, vf5 + (.add.mul.x.vf acc vf1 vf5 acc) + + ;;lqc2 vf8, 48(a2) + (.lvf vf8 (-> src 3)) + + ;;vmadday.xyzw acc, vf2, vf5 + (.add.mul.y.vf acc vf2 vf5 acc) + + ;;daddiu a2, a2, 64 + ;;(&+! src 64) + (set! src (the (inline-array vector) (+ 64 (the int src)))) + + ;;vmaddz.xyz vf5, vf3, vf5 + (.add.mul.z.vf vf5 vf3 vf5 acc :mask #b0111) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + ;;daddiu v1, a3, -1 + (set! v1 (- count 1)) + + ;;vmulaw.xyzw acc, vf4, vf0 + (.mul.w.vf acc vf4 vf0) + + ;;vmaddax.xyzw acc, vf1, vf6 + (.add.mul.x.vf acc vf1 vf6 acc) + + ;; vmadday.xyzw acc, vf2, vf6 + (.add.mul.y.vf acc vf2 vf6 acc) + + ;; vmaddz.xyz vf6, vf3, vf6 + (.add.mul.z.vf vf6 vf3 vf6 acc :mask #b0111) + + ;;sqc2 vf5, 0(a1) + (.svf (-> dst 0) vf5) + + ;;beq v1, r0, L3 + ;;vmulaw.xyzw acc, vf4, vf0 + (.mul.w.vf acc vf4 vf0) + (when-goto (zero? v1) end) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + + ;;vmaddax.xyzw acc, vf1, vf7 + (.add.mul.x.vf acc vf1 vf7 acc) + ;;daddiu v1, v1, -1 + (+! v1 -1) + ;;vmadday.xyzw acc, vf2, vf7 + (.add.mul.y.vf acc vf2 vf7 acc) + ;;lqc2 vf5, 0(a2) + (.lvf vf5 (-> src 0)) + ;;vmaddz.xyz vf7, vf3, vf7 + (.add.mul.z.vf vf7 vf3 vf7 acc :mask #b0111) + ;;sqc2 vf6, 16(a1) + (.svf (-> dst 1) vf6) + + ;;beq v1, r0, L3 + ;;vmulaw.xyzw acc, vf4, vf0 + (.mul.w.vf acc vf4 vf0) + (when-goto (zero? v1) end) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + ;;vmaddax.xyzw acc, vf1, vf8 + (.add.mul.x.vf acc vf1 vf8 acc) + ;;daddiu v1, v1, -1 + (+! v1 -1) + ;;vmadday.xyzw acc, vf2, vf8 + (.add.mul.y.vf acc vf2 vf8 acc) + ;;lqc2 vf6, 16(a2) + (.lvf vf6 (-> src 1)) + ;;vmaddz.xyz vf8, vf3, vf8 + (.add.mul.z.vf vf8 vf3 vf8 acc :mask #b0111) + ;;sqc2 vf7, 32(a1) + (.svf (-> dst 2) vf7) + + ;;beq v1, r0, L3 + ;;daddiu a1, a1, 64 + ;;(&!+ dst 64) + (set! dst (the (inline-array vector) (+ 64 (the int dst)))) + (when-goto (zero? v1) end) + + ;;daddiu a3, v1, -1 + (set! count (- v1 1)) + ;;sqc2 vf8, -16(a1) + (.svf dst vf8 :offset -16) + (when-goto (not (zero? count)) loop-top) + (label end) + (none) + ) + ) + + +(defun matrix-mirror! ((arg0 matrix) (arg1 vector) (arg2 vector)) + (let ((f10-0 -2.0) + (f0-0 1.0) + ) + (let* ((f1-0 0.0) + (f9-0 (-> arg2 x)) + (f12-0 (-> arg2 y)) + (f11-0 (-> arg2 z)) + (f6-0 (-> arg1 x)) + (f5-0 (-> arg1 y)) + (f2-0 (-> arg1 z)) + (f3-2 (+ f0-0 (* f10-0 f9-0 f9-0))) + (f4-2 (+ f0-0 (* f10-0 f12-0 f12-0))) + (f7-2 (+ f0-0 (* f10-0 f11-0 f11-0))) + (f8-1 (* f10-0 f9-0 f12-0)) + (f9-2 (* f10-0 f9-0 f11-0)) + (f10-2 (* f10-0 f12-0 f11-0)) + (f11-4 (- f6-0 (+ (* f6-0 f3-2) (* f5-0 f8-1) (* f2-0 f9-2)))) + (f12-6 (- f5-0 (+ (* f6-0 f8-1) (* f5-0 f4-2) (* f2-0 f10-2)))) + (f2-1 (- f2-0 (+ (* f6-0 f9-2) (* f5-0 f10-2) (* f2-0 f7-2)))) + ) + (set! (-> arg0 data 0) f3-2) + (set! (-> arg0 data 1) f8-1) + (set! (-> arg0 data 2) f9-2) + (set! (-> arg0 data 3) f1-0) + (set! (-> arg0 data 4) f8-1) + (set! (-> arg0 data 5) f4-2) + (set! (-> arg0 data 6) f10-2) + (set! (-> arg0 data 7) f1-0) + (set! (-> arg0 data 8) f9-2) + (set! (-> arg0 data 9) f10-2) + (set! (-> arg0 data 10) f7-2) + (set! (-> arg0 data 11) f1-0) + (set! (-> arg0 trans x) f11-4) + (set! (-> arg0 trans y) f12-6) + (set! (-> arg0 trans z) f2-1) + ) + (set! (-> arg0 trans w) f0-0) + ) + arg0 + ) + + + + diff --git a/goal_src/jak2/engine/math/quaternion-h.gc b/goal_src/jak2/engine/math/quaternion-h.gc index f6baeaa122..ea3f3464db 100644 --- a/goal_src/jak2/engine/math/quaternion-h.gc +++ b/goal_src/jak2/engine/math/quaternion-h.gc @@ -5,3 +5,22 @@ ;; name in dgo: quaternion-h ;; dgos: ENGINE, GAME +(deftype quaternion (structure) + ((data float 4 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (z float :offset 8) + (w float :offset 12) + (vec vector :inline :offset 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(define *unity-quaternion* (new 'static 'quaternion :data (new 'static 'array float 4 0.0 0.0 0.0 1.0))) + +(define-extern quaternion->matrix (function matrix quaternion matrix)) +(define-extern matrix->quaternion (function quaternion matrix quaternion)) +(define-extern vector-y-angle (function vector float)) diff --git a/goal_src/jak2/engine/math/transform-h.gc b/goal_src/jak2/engine/math/transform-h.gc index b38be6d51d..bef9ef4a5d 100644 --- a/goal_src/jak2/engine/math/transform-h.gc +++ b/goal_src/jak2/engine/math/transform-h.gc @@ -5,3 +5,22 @@ ;; name in dgo: transform-h ;; dgos: ENGINE, GAME +(deftype transform (structure) + ((trans vector :inline :offset-assert 0) + (rot vector :inline :offset-assert 16) + (scale vector :inline :offset-assert 32) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype trs (basic) + ((trans vector :inline :offset-assert 16) + (rot vector :inline :offset-assert 32) + (scale vector :inline :offset-assert 48) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) \ No newline at end of file diff --git a/goal_src/jak2/engine/math/transform.gc b/goal_src/jak2/engine/math/transform.gc index 2a41ebf74c..87c7af7b3a 100644 --- a/goal_src/jak2/engine/math/transform.gc +++ b/goal_src/jak2/engine/math/transform.gc @@ -5,3 +5,79 @@ ;; name in dgo: transform ;; dgos: ENGINE, GAME +(defmethod print transform ((obj transform)) + (format #t "# obj trans x) (-> obj trans y) (-> obj trans z) (-> obj trans w)) + (format #t "~T~Trot: ~F ~F ~F ~F ~%" (-> obj rot x) (-> obj rot y) (-> obj rot z) (-> obj rot w)) + (format #t "~T~Tscale:~F ~F ~F ~F>" (-> obj scale x) (-> obj scale y) (-> obj scale z) (-> obj scale w)) + obj + ) + +(defmethod new trs ((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 trans w) 1.0) + (set! (-> gp-0 rot w) 1.0) + (vector-identity! (-> gp-0 scale)) + gp-0 + ) + ) + +(defun transform-matrix-calc! ((arg0 transform) (arg1 matrix)) + (let ((s4-0 (new 'stack-no-clear 'matrix))) + (set! (-> s4-0 quad 0) (the-as uint128 0)) + (set! (-> s4-0 quad 1) (the-as uint128 0)) + (set! (-> s4-0 quad 2) (the-as uint128 0)) + (set! (-> s4-0 trans quad) (the-as uint128 0)) + (let ((s3-0 (new 'stack-no-clear 'matrix))) + (set! (-> s3-0 quad 0) (the-as uint128 0)) + (set! (-> s3-0 quad 1) (the-as uint128 0)) + (set! (-> s3-0 quad 2) (the-as uint128 0)) + (set! (-> s3-0 trans quad) (the-as uint128 0)) + (matrix-identity! arg1) + (matrix-translate! arg1 (-> arg0 trans)) + (matrix-rotate-y! s4-0 (-> arg0 rot y)) + (matrix*! s3-0 s4-0 arg1) + (matrix-rotate-x! s4-0 (-> arg0 rot x)) + (matrix*! arg1 s4-0 s3-0) + (matrix-rotate-z! s4-0 (-> arg0 rot z)) + (matrix*! s3-0 s4-0 arg1) + (matrix-scale! s4-0 (-> arg0 scale)) + (matrix*! arg1 s4-0 s3-0) + ) + ) + ) + +(defun transform-matrix-parent-calc! ((arg0 transform) (arg1 matrix) (arg2 vector)) + (let ((s4-0 (new 'stack-no-clear 'matrix))) + (set! (-> s4-0 quad 0) (the-as uint128 0)) + (set! (-> s4-0 quad 1) (the-as uint128 0)) + (set! (-> s4-0 quad 2) (the-as uint128 0)) + (set! (-> s4-0 trans quad) (the-as uint128 0)) + (let ((s3-0 (new 'stack-no-clear 'matrix))) + (set! (-> s3-0 quad 0) (the-as uint128 0)) + (set! (-> s3-0 quad 1) (the-as uint128 0)) + (set! (-> s3-0 quad 2) (the-as uint128 0)) + (set! (-> s3-0 trans quad) (the-as uint128 0)) + (matrix-identity! s3-0) + (matrix-translate! s3-0 (-> arg0 trans)) + (matrix-inv-scale! s4-0 arg2) + (matrix*! arg1 s4-0 s3-0) + (matrix-rotate-y! s4-0 (-> arg0 rot y)) + (matrix*! s3-0 s4-0 arg1) + (matrix-rotate-x! s4-0 (-> arg0 rot x)) + (matrix*! arg1 s4-0 s3-0) + (matrix-rotate-z! s4-0 (-> arg0 rot z)) + (matrix*! s3-0 s4-0 arg1) + (matrix-scale! s4-0 (-> arg0 scale)) + (matrix*! arg1 s4-0 s3-0) + ) + ) + ) + +(defun trs-matrix-calc! ((arg0 trs) (arg1 matrix)) + (transform-matrix-calc! (the-as transform (-> arg0 trans)) arg1) + ) + + + + diff --git a/goal_src/jak2/engine/math/transformq-h.gc b/goal_src/jak2/engine/math/transformq-h.gc index 3a33ee7496..4354c728aa 100644 --- a/goal_src/jak2/engine/math/transformq-h.gc +++ b/goal_src/jak2/engine/math/transformq-h.gc @@ -5,3 +5,62 @@ ;; name in dgo: transformq-h ;; dgos: ENGINE, GAME +(deftype transformq (transform) + ((quat quaternion :inline :offset 16) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype trsq (trs) + ((quat quaternion :inline :offset 32) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + +(deftype trsqv (trsq) + ((pause-adjust-distance meters :offset 4) + (nav-radius meters :offset 8) + (transv vector :inline :offset-assert 64) + (rotv vector :inline :offset-assert 80) + (scalev vector :inline :offset-assert 96) + (dir-targ quaternion :inline :offset-assert 112) + (angle-change-time uint64 :offset-assert 128) + (old-y-angle-diff float :offset-assert 136) + ) + :method-count-assert 28 + :size-assert #x8c + :flag-assert #x1c0000008c + (: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) + (y-angle (_type_) float 22) + (global-y-angle-to-point (_type_ vector) float 23) + (relative-y-angle-to-point (_type_ vector) float 24) + (dummy-25 () none 25) + (dummy-26 () none 26) + (dummy-27 () none 27) + ) + ) + +(defmethod global-y-angle-to-point trsqv ((obj trsqv) (arg0 vector)) + (vector-y-angle (vector-! (new 'stack-no-clear 'vector) arg0 (-> obj trans))) + ) + +(defmethod relative-y-angle-to-point trsqv ((obj trsqv) (arg0 vector)) + (deg-diff (y-angle obj) (vector-y-angle (vector-! (new 'stack-no-clear 'vector) arg0 (-> obj trans)))) + ) \ No newline at end of file diff --git a/goal_src/jak2/engine/math/trigonometry-h.gc b/goal_src/jak2/engine/math/trigonometry-h.gc index 7a4f9337aa..99adcb8c47 100644 --- a/goal_src/jak2/engine/math/trigonometry-h.gc +++ b/goal_src/jak2/engine/math/trigonometry-h.gc @@ -5,3 +5,8 @@ ;; name in dgo: trigonometry-h ;; dgos: ENGINE, GAME +(define-extern deg-diff (function float float float)) +(define-extern sin (function float float)) +(define-extern vector-sincos! (function vector vector vector int)) +(define-extern cos (function float float)) +(define-extern atan (function float float float)) diff --git a/goal_src/jak2/engine/math/vector-h.gc b/goal_src/jak2/engine/math/vector-h.gc index 07ae439dfe..b52344f9f3 100644 --- a/goal_src/jak2/engine/math/vector-h.gc +++ b/goal_src/jak2/engine/math/vector-h.gc @@ -5,3 +5,647 @@ ;; name in dgo: vector-h ;; dgos: ENGINE, GAME +(define-extern vector-cross! (function vector vector vector vector)) +(define-extern vector-float*! (function vector vector float 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-normalize! (function vector float vector)) +(define-extern vector-normalize-copy! (function vector vector float vector)) + + +(defmacro init-vf0-vector () + "Initializes the VF0 vector which is a constant vector in the VU set to <0,0,0,1>" + `(.lvf vf0 (new 'static 'vector :x 0.0 :y 0.0 :z 0.0 :w 1.0)) + ) + +(deftype bit-array (basic) + ((length int32 :offset-assert 4) + (allocated-length int32 :offset-assert 8) + (_pad uint8 :offset-assert 12) + (bytes uint8 :dynamic :offset 12) + ) + :method-count-assert 13 + :size-assert #xd + :flag-assert #xd0000000d + (:methods + (new (symbol type int) _type_ 0) + (get-bit (_type_ int) symbol 9) + (clear-bit (_type_ int) int 10) + (set-bit (_type_ int) int 11) + (clear-all! (_type_) _type_ 12) + ) + ) + +(defmethod new bit-array ((allocation symbol) (type-to-make type) (arg0 int)) + (let ((v0-0 (object-new allocation type-to-make (+ (/ (logand -8 (+ arg0 7)) 8) -1 (-> type-to-make size))))) + (set! (-> v0-0 length) arg0) + (set! (-> v0-0 allocated-length) arg0) + v0-0 + ) + ) + +(defmethod length bit-array ((obj bit-array)) + (-> obj length) + ) + +(defmethod asize-of bit-array ((obj bit-array)) + (the-as int (+ (-> obj type size) (/ (logand -8 (+ (-> obj allocated-length) 7)) 8))) + ) + +(defmethod get-bit bit-array ((obj bit-array) (arg0 int)) + (let ((v1-2 (-> obj bytes (/ arg0 8)))) + (logtest? v1-2 (ash 1 (logand arg0 7))) + ) + ) + +(defmethod clear-bit bit-array ((obj bit-array) (arg0 int)) + (logclear! (-> obj bytes (/ arg0 8)) (ash 1 (logand arg0 7))) + 0 + ) + +(defmethod set-bit bit-array ((obj bit-array) (arg0 int)) + (logior! (-> obj bytes (/ arg0 8)) (ash 1 (logand arg0 7))) + 0 + ) + +(defmethod clear-all! bit-array ((obj bit-array)) + (countdown (v1-2 (/ (logand -8 (+ (-> obj allocated-length) 7)) 8)) + (nop!) + (nop!) + (set! (-> obj bytes v1-2) (the-as uint 0)) + ) + obj + ) + +(deftype vector16ub (structure) + ((data uint8 16 :offset-assert 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype vector4ub (structure) + ((data uint8 4 :offset-assert 0) + (x uint8 :offset 0) + (y uint8 :offset 1) + (z uint8 :offset 2) + (w uint8 :offset 3) + (clr uint32 :offset 0) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype vector4b (structure) + ((data int8 4 :offset-assert 0) + (x int8 :offset 0) + (y int8 :offset 1) + (z int8 :offset 2) + (w int8 :offset 3) + (clr int32 :offset 0) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype vector2ub (structure) + ((data uint8 2 :offset-assert 0) + (x uint8 :offset 0) + (y uint8 :offset 1) + (clr uint16 :offset 0) + ) + :method-count-assert 9 + :size-assert #x2 + :flag-assert #x900000002 + ) + +(deftype vector2b (structure) + ((data int8 2 :offset-assert 0) + (x int8 :offset 0) + (y int8 :offset 1) + (clr int16 :offset 0) + ) + :method-count-assert 9 + :size-assert #x2 + :flag-assert #x900000002 + ) + +(deftype vector2h (structure) + ((data int16 2 :offset-assert 0) + (x int16 :offset 0) + (y int16 :offset 2) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype vector2uh (structure) + ((data uint16 2 :offset-assert 0) + (x uint16 :offset 0) + (y uint16 :offset 2) + (val uint32 :offset 0) + ) + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) + +(deftype vector3h (structure) + ((data int16 3 :offset-assert 0) + (x int16 :offset 0) + (y int16 :offset 2) + (z int16 :offset 4) + ) + :method-count-assert 9 + :size-assert #x6 + :flag-assert #x900000006 + ) + +(deftype vector3uh (structure) + ((data uint16 3 :offset-assert 0) + (x uint16 :offset 0) + (y uint16 :offset 2) + (z uint16 :offset 4) + ) + :method-count-assert 9 + :size-assert #x6 + :flag-assert #x900000006 + ) + +(deftype vector2w (structure) + ((data int32 2 :offset-assert 0) + (x int32 :offset 0) + (y int32 :offset 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype vector3w (structure) + ((data int32 3 :offset-assert 0) + (x int32 :offset 0) + (y int32 :offset 4) + (z int32 :offset 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +(deftype vector4w (structure) + ((data uint32 4 :offset-assert 0) + (x int32 :offset 0) + (y int32 :offset 4) + (z int32 :offset 8) + (w int32 :offset 12) + (dword uint64 2 :offset 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype vector2 (structure) + ((data float 2 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype vector3 (structure) + ((data float 3 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (z float :offset 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +(deftype vector4 (structure) + ((data float 4 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (z float :offset 8) + (w float :offset 12) + (dword uint64 2 :offset 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(defmethod print vector4w ((obj vector4w)) + (format #t "#" (-> obj x) (-> obj y) (-> obj z) (-> obj w) obj) + obj + ) + +(deftype vector4w-2 (structure) + ((data int32 8 :offset-assert 0) + (quad uint128 2 :offset 0) + (vector vector4w 2 :inline :offset 0) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(deftype vector4w-3 (structure) + ((data int32 12 :offset-assert 0) + (quad uint128 3 :offset 0) + (vector vector4w 3 :inline :offset 0) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype vector4w-4 (structure) + ((data int32 16 :offset-assert 0) + (quad uint128 4 :offset 0) + (vector vector4w 4 :inline :offset 0) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + + +(deftype vector4h (structure) + ((data int16 4 :offset-assert 0) + (x int16 :offset 0) + (y int16 :offset 2) + (z int16 :offset 4) + (w int16 :offset 6) + (long uint64 :offset 0) + ) + :method-count-assert 9 + :size-assert #x8 + :flag-assert #x900000008 + ) + +(deftype vector8h (structure) + ((data int16 8 :offset-assert 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype vector16b (structure) + ((data int8 16 :offset-assert 0) + (quad uint128 :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(defmethod inspect vector ((obj vector)) + (format #t "[~8x] vector~%" obj) + (format #t "~T[~F] [~F] [~F] [~F]~%" (-> obj x) (-> obj y) (-> obj z) (-> obj w)) + obj + ) + +(defmethod print vector ((obj vector)) + (format #t "#" (-> obj x) (-> obj y) (-> obj z) (-> obj w) obj) + obj + ) + +(define *null-vector* (new 'static 'vector :w 1.0)) +(define *identity-vector* (new 'static 'vector :x 1.0 :y 1.0 :z 1.0 :w 1.0)) +(define *x-vector* (new 'static 'vector :x 1.0 :w 1.0)) +(define *y-vector* (new 'static 'vector :y 1.0 :w 1.0)) +(define *z-vector* (new 'static 'vector :z 1.0 :w 1.0)) +(define *up-vector* (new 'static 'vector :y 1.0 :w 1.0)) + +(deftype vector4s-3 (structure) + ((data float 12 :offset-assert 0) + (quad uint128 3 :offset 0) + (vector vector 3 :inline :offset 0) + ) + :method-count-assert 9 + :size-assert #x30 + :flag-assert #x900000030 + ) + +(deftype vector-array (inline-array-class) + ((data vector :inline :dynamic :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) +(set! (-> vector-array heap-base) (the-as uint 16)) + +(deftype rgbaf (vector) + ((r float :offset 0) + (g float :offset 4) + (b float :offset 8) + (a float :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype plane (vector) + ((a float :offset 0) + (b float :offset 4) + (c float :offset 8) + (d float :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype sphere (vector) + ((r float :offset 12) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype isphere (vec4s) + () + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype box8s (structure) + ((data float 8 :offset-assert 0) + (quad uint128 2 :offset 0) + (vector vector 2 :offset 0) + (min vector :inline :offset 0) + (max vector :inline :offset 16) + ) + :method-count-assert 9 + :size-assert #x20 + :flag-assert #x900000020 + ) + +(deftype box8s-array (inline-array-class) + ((data box8s :inline :dynamic :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) +(set! (-> box8s-array heap-base) (the-as uint 32)) + +(deftype cylinder (structure) + ((origin vector :inline :offset-assert 0) + (axis vector :inline :offset-assert 16) + (radius float :offset-assert 32) + (length float :offset-assert 36) + ) + :method-count-assert 11 + :size-assert #x28 + :flag-assert #xb00000028 + (:methods + (debug-draw (_type_ vector4w) none 9) + (ray-capsule-intersect (_type_ vector vector) float 10) + ) + ) + +(deftype cylinder-flat (structure) + ((origin vector :inline :offset-assert 0) + (axis vector :inline :offset-assert 16) + (radius float :offset-assert 32) + (length float :offset-assert 36) + ) + :method-count-assert 11 + :size-assert #x28 + :flag-assert #xb00000028 + (:methods + (debug-draw (_type_ vector4w) none 9) + (ray-flat-cyl-intersect (_type_ vector vector) float 10) + ) + ) + +(deftype vertical-planes (structure) + ((data uint128 4 :offset-assert 0) + ) + :method-count-assert 9 + :size-assert #x40 + :flag-assert #x900000040 + ) + +(deftype vertical-planes-array (basic) + ((length uint32 :offset-assert 4) + (data vertical-planes :inline :dynamic :offset-assert 16) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype qword (structure) + ((data uint32 4 :offset-assert 0) + (byte uint8 16 :offset 0) + (hword uint16 8 :offset 0) + (word uint32 4 :offset 0) + (dword uint64 2 :offset 0) + (quad uint128 :offset 0) + (vector vector :inline :offset 0) + (vector4w vector4w :inline :offset 0) + ) + :method-count-assert 9 + :size-assert #x10 + :flag-assert #x900000010 + ) + +(deftype vector3s (structure) + ((data float 3 :offset-assert 0) + (x float :offset 0) + (y float :offset 4) + (z float :offset 8) + ) + :method-count-assert 9 + :size-assert #xc + :flag-assert #x90000000c + ) + +(defun vector-dot ((a vector) (b vector)) + "Take the dot product of two vectors. + Only does the x, y, z compoments. + Originally handwritten assembly to space out loads and use FPU accumulator" + (declare (inline)) + (let ((result 0.)) + (+! result (* (-> a x) (-> b x))) + (+! result (* (-> a y) (-> b y))) + (+! result (* (-> a z) (-> b z))) + result + ) + ) + +(defun vector-dot-vu ((arg0 vector) (arg1 vector)) + (local-vars (v0-0 float)) + (rlet ((vf1 :class vf) + (vf2 :class vf) + ) + (.lvf vf1 (&-> arg0 quad)) + (.lvf vf2 (&-> arg1 quad)) + (.mul.vf vf1 vf1 vf2) + (.add.y.vf vf1 vf1 vf1 :mask #b1) + (.add.z.vf vf1 vf1 vf1 :mask #b1) + (.mov v0-0 vf1) + v0-0 + ) + ) + +(defun vector4-dot ((a vector) (b vector)) + "Take the dot product of two vectors. + Does the x, y, z, and w compoments" + (declare (inline)) + (let ((result 0.)) + (+! result (* (-> a x) (-> b x))) + (+! result (* (-> a y) (-> b y))) + (+! result (* (-> a z) (-> b z))) + (+! result (* (-> a w) (-> b w))) + result + ) + ) + +(defun vector4-dot-vu ((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)) + (.mul.vf vf1 vf1 vf2) + (.add.w.vf vf3 vf0 vf0 :mask #b1) + (.mul.x.vf acc vf3 vf1 :mask #b1) + (.add.mul.y.vf acc vf3 vf1 acc :mask #b1) + (.add.mul.z.vf acc vf3 vf1 acc :mask #b1) + (.add.mul.w.vf vf1 vf3 vf1 acc :mask #b1) + (.mov v0-0 vf1) + v0-0 + ) + ) + +(defun vector+! ((dst vector) (a vector) (b vector)) + "Set dst = a + b. The w component of dst is set to 0." + (declare (inline)) + (rlet ((vf0 :class vf :reset-here #t) + (vf1 :class vf :reset-here #t) + (vf2 :class vf :reset-here #t) + (vf3 :class vf :reset-here #t)) + ;; load vectors + (.lvf vf2 a) + (.lvf vf3 b) + (init-vf0-vector) + ;; add + (.add.vf vf1 vf2 vf3) + ;; set w = 1 + (.blend.vf vf1 vf1 vf0 :mask #b1000) + ;; store + (.svf dst vf1) + ) + dst + ) + +(defun vector-! ((dst vector) (a vector) (b vector)) + "Set dst = a - b. The w componenent of dst is set to 0." + (declare (inline)) + (rlet ((vf0 :class vf :reset-here #t) + (vf1 :class vf :reset-here #t) + (vf2 :class vf :reset-here #t) + (vf3 :class vf :reset-here #t)) + ;; load vectors + (.lvf vf2 a) + (.lvf vf3 b) + (init-vf0-vector) + ;; subtract + (.sub.vf vf1 vf2 vf3) + ;; set w = 1 + (.blend.vf vf1 vf1 vf0 :mask #b1000) + ;; store + (.svf dst vf1) + ) + dst + ) + +(defun vector-zero! ((dest vector)) + "Set xyzw to 0." + (declare (inline)) + (rlet ((vf1 :class vf :reset-here #t)) + ;; set vf1 = 0 + (.xor.vf vf1 vf1 vf1) + ;; store the 0 + (.svf dest vf1) + ) + dest + ) + +(defun vector-reset! ((dst vector)) + "Set vector to 0,0,0,1." + (declare (inline)) + (vector-zero! dst) + (set! (-> dst w) 1.0) + dst + ) + +(defun vector-copy! ((arg0 vector) (arg1 vector)) + (set! (-> arg0 quad) (-> arg1 quad)) + arg0 + ) + +(defun vector-length< ((arg0 vector) (arg1 float)) + (let ((f0-0 (vector-length-squared arg0)) + (f1-0 arg1) + ) + (< f0-0 (* f1-0 f1-0)) + ) + ) + +(defun vector-length> ((arg0 vector) (arg1 float)) + (< (* arg1 arg1) (vector-length-squared arg0)) + ) + +(define *zero-vector* (new 'static 'vector)) + + +(defmacro new-stack-vector0 () + "Get a stack vector that's set to 0. + This is more efficient than (new 'stack 'vector) because + this doesn't call the constructor." + `(let ((vec (new 'stack-no-clear 'vector))) + (set! (-> vec quad) (the-as uint128 0)) + vec + ) + ) + +(defmacro set-vector! (v xv yv zv wv) + "Set all fields in a vector" + (with-gensyms (vec) + `(let ((,vec ,v)) + (set! (-> ,vec x) ,xv) + (set! (-> ,vec y) ,yv) + (set! (-> ,vec z) ,zv) + (set! (-> ,vec w) ,wv) + ,vec + )) + ) \ No newline at end of file diff --git a/goal_src/jak2/engine/ps2/timer-h.gc b/goal_src/jak2/engine/ps2/timer-h.gc index 1cc09f6af6..b4c081fe90 100644 --- a/goal_src/jak2/engine/ps2/timer-h.gc +++ b/goal_src/jak2/engine/ps2/timer-h.gc @@ -30,6 +30,14 @@ ;; Timer HW ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defenum timer-clock-selection + :type uint8 + (busclk 0) + (busclk/16 1) + (busclk/256 2) + (hblank 3) + ) + (deftype timer-mode (uint32) ((clks timer-clock-selection :offset 0 :size 2) (gate uint8 :offset 2 :size 1) diff --git a/goal_src/jak2/engine/util/types-h.gc b/goal_src/jak2/engine/util/types-h.gc index ac9542fb42..0db8bc656a 100644 --- a/goal_src/jak2/engine/util/types-h.gc +++ b/goal_src/jak2/engine/util/types-h.gc @@ -5,3 +5,9 @@ ;; name in dgo: types-h ;; dgos: ENGINE, GAME +(deftype part-id (uint32) + () + :method-count-assert 9 + :size-assert #x4 + :flag-assert #x900000004 + ) \ No newline at end of file diff --git a/goal_src/jak2/game.gp b/goal_src/jak2/game.gp index 8e14c734e7..627f0b5c72 100644 --- a/goal_src/jak2/game.gp +++ b/goal_src/jak2/game.gp @@ -161,6 +161,404 @@ (cgo "KERNEL.CGO" "kernel.gd") +;;;;;;;;;;;;; +;; engine +;;;;;;;;;;;;; + +(goal-src-sequence + "engine/" + :deps + ("$OUT/obj/gcommon.o" + "$OUT/obj/gstate.o" + "$OUT/obj/gstring.o" + "$OUT/obj/gkernel.o" + ) +"util/types-h.gc" +"ps2/vu1-macros.gc" +"math/math.gc" +"math/vector-h.gc" +"physics/gravity-h.gc" +"geometry/bounding-box-h.gc" +"math/matrix-h.gc" +"math/quaternion-h.gc" +"math/euler-h.gc" +"math/transform-h.gc" +"geometry/geometry-h.gc" +"math/trigonometry-h.gc" +"math/transformq-h.gc" +"geometry/bounding-box.gc" +"math/matrix.gc" +"math/transform.gc" +"math/quaternion.gc" +"math/euler.gc" +"math/trigonometry.gc" +"sound/gsound-h.gc" +"ps2/timer-h.gc" +"ps2/vif-h.gc" +"dma/dma-h.gc" +"gfx/hw/video-h.gc" +"gfx/vu1-user-h.gc" +"util/profile-h.gc" +"dma/dma.gc" +"dma/dma-buffer.gc" +"dma/dma-bucket.gc" +"dma/dma-disasm.gc" +"ps2/pad.gc" +"gfx/hw/gs.gc" +"gfx/hw/display-h.gc" +"geometry/geometry.gc" +"ps2/timer.gc" +"math/vector.gc" +"load/file-io.gc" +"load/loader-h.gc" +"gfx/texture/texture-h.gc" +"gfx/texture/texture-anim-h.gc" +"gfx/lights-h.gc" +"gfx/mood/mood-h.gc" +"level/level-h.gc" +"util/capture-h.gc" +"gfx/math-camera-h.gc" +"gfx/math-camera.gc" +"gfx/font-h.gc" +"load/decomp-h.gc" +"util/profile.gc" +"gfx/hw/display.gc" +"engine/connect.gc" +"ui/text-id-h.gc" +"ui/text-h.gc" +"camera/camera-defs-h.gc" +) + +(goal-src-sequence + "levels/" + :deps ("$OUT/obj/camera-defs-h.o") + "city/common/trail-h.gc" + ) + +(goal-src-sequence + "engine/" + :deps + ("$OUT/obj/trail-h.o") +"ui/minimap-h.gc" +"ui/bigmap-h.gc" +"game/settings-h.gc" +"util/capture.gc" +"debug/memory-usage-h.gc" +"gfx/blit-displays-h.gc" +"gfx/texture/texture.gc" +"game/main-h.gc" +"anim/mspace-h.gc" +"draw/drawable-h.gc" +"draw/drawable-group-h.gc" +"draw/drawable-inline-array-h.gc" +"draw/draw-node-h.gc" +"draw/drawable-tree-h.gc" +"draw/drawable-actor-h.gc" +"level/region-h.gc" +"ai/traffic-h.gc" +"game/task/game-task-h.gc" +"game/task/task-control-h.gc" +"gfx/generic/generic-h.gc" +"gfx/sky/sky-h.gc" +"gfx/ocean/ocean-h.gc" +"gfx/ocean/ocean-trans-tables.gc" +"gfx/ocean/ocean-tables.gc" +"gfx/ocean/ocean-frames.gc" +"gfx/mood/time-of-day-h.gc" +"data/art-h.gc" +"gfx/generic/generic-vu1-h.gc" +"gfx/merc/merc-h.gc" +"gfx/merc/generic-merc-h.gc" +"gfx/tie/generic-tie-h.gc" +"gfx/generic/generic-work-h.gc" +"gfx/foreground/shadow-cpu-h.gc" +"gfx/foreground/shadow-vu1-h.gc" +"ps2/memcard-h.gc" +"game/game-info-h.gc" +"ui/gui-h.gc" +"ambient/ambient-h.gc" +"sound/speech-h.gc" +"gfx/background/wind-h.gc" +"gfx/background/prototype-h.gc" +"anim/joint-h.gc" +"gfx/foreground/bones-h.gc" +"gfx/foreground/foreground-h.gc" +"engine/engines.gc" +"gfx/lightning-h.gc" +"entity/res-h.gc" +"entity/res.gc" +"gfx/lights.gc" +"physics/dynamics-h.gc" +"target/surface-h.gc" +"collide/pat-h.gc" +"game/fact-h.gc" +"anim/aligner-h.gc" +"game/penetrate-h.gc" +"game/game-h.gc" +"util/script-h.gc" +"scene/scene-h.gc" +"util/sync-info-h.gc" +"camera/pov-camera-h.gc" +"util/smush-control-h.gc" +"debug/debug-h.gc" +"anim/joint-mod-h.gc" +"collide/collide-func-h.gc" +"collide/collide-mesh-h.gc" +"collide/collide-shape-h.gc" +"common_objs/generic-obs-h.gc" +"physics/trajectory-h.gc" +"collide/collide-target-h.gc" +"collide/collide-touch-h.gc" +"collide/collide-edge-grab-h.gc" +"process-drawable/process-drawable-h.gc" +"process-drawable/process-focusable.gc" +"process-drawable/process-taskable-h.gc" +"process-drawable/focus.gc" +"game/effect-control-h.gc" +"collide/collide-frag-h.gc" +"spatial-hash/collide-hash-h.gc" +"physics/chain-physics-h.gc" +"common_objs/projectile-h.gc" +"collide/find-nearest-h.gc" +"target/target-h.gc" +"debug/stats-h.gc" +"level/bsp-h.gc" +"collide/collide-cache-h.gc" +"collide/collide-h.gc" +"gfx/shrub/shrubbery-h.gc" +"gfx/tie/tie-h.gc" +"gfx/tfrag/tfrag-h.gc" +"gfx/background/background-h.gc" +"gfx/background/subdivide-h.gc" +"entity/entity-h.gc" +"gfx/sprite/sprite-h.gc" +"gfx/sprite/simple-sprite-h.gc" +"gfx/foreground/eye-h.gc" +"gfx/sprite/particles/sparticle-launcher-h.gc" +"gfx/sprite/particles/sparticle-h.gc" +"entity/actor-link-h.gc" +"camera/camera-h.gc" +"camera/cam-debug-h.gc" +"camera/cam-interface-h.gc" +"camera/cam-update-h.gc" +"ui/hud-h.gc" +"ui/progress/progress-h.gc" +"ps2/rpc-h.gc" +"geometry/path-h.gc" +"nav/nav-mesh-h.gc" +"nav/nav-control-h.gc" +"spatial-hash/spatial-hash-h.gc" +"spatial-hash/actor-hash-h.gc" +"load/load-dgo.gc" +"load/ramdisk.gc" +"sound/gsound.gc" +"math/transformq.gc" +"collide/collide-func.gc" +"anim/joint.gc" +"anim/joint-mod.gc" +"physics/chain-physics.gc" +"geometry/cylinder.gc" +"gfx/background/wind-work.gc" +"gfx/background/wind.gc" +"level/bsp.gc" +"gfx/background/subdivide.gc" +"gfx/sprite/sprite.gc" +"gfx/sprite/sprite-distort.gc" +"gfx/sprite/sprite-glow.gc" +"debug/debug-sphere.gc" +"debug/debug.gc" +"debug/history.gc" +"gfx/merc/merc-vu1.gc" +"gfx/merc/emerc-vu1.gc" +"gfx/merc/merc-blend-shape.gc" +"gfx/merc/merc.gc" +"gfx/merc/emerc.gc" +"gfx/foreground/ripple.gc" +"gfx/foreground/bones.gc" +"gfx/foreground/debug-foreground.gc" +"gfx/foreground/foreground.gc" +"gfx/generic/generic-vu0.gc" +"gfx/generic/generic-vu1.gc" +"gfx/generic/generic-effect.gc" +"gfx/generic/generic-merc.gc" +"gfx/generic/generic-tie.gc" +"gfx/foreground/shadow-cpu.gc" +"gfx/foreground/shadow-vu1.gc" +"gfx/warp.gc" +"gfx/texture/texture-anim.gc" +"gfx/texture/texture-anim-funcs.gc" +"gfx/texture/texture-anim-tables.gc" +"gfx/blit-displays.gc" +"data/font-data.gc" +"gfx/font.gc" +"load/decomp.gc" +"gfx/background/background.gc" +"draw/draw-node.gc" +"gfx/shrub/shrubbery.gc" +"gfx/shrub/shrub-work.gc" +"gfx/tfrag/tfrag-near.gc" +"gfx/tfrag/tfrag.gc" +"gfx/tfrag/tfrag-methods.gc" +"gfx/tfrag/tfrag-work.gc" +"gfx/tie/tie.gc" +"gfx/tie/etie-vu1.gc" +"gfx/tie/etie-near-vu1.gc" +"gfx/tie/tie-near.gc" +"gfx/tie/tie-work.gc" +"gfx/tie/tie-methods.gc" +"util/sync-info.gc" +"physics/trajectory.gc" +"gfx/sprite/particles/sparticle-launcher.gc" +"gfx/sprite/particles/sparticle.gc" +"entity/entity-table.gc" +"load/loader.gc" +"game/game-info.gc" +"game/task/game-task.gc" +"game/game-save.gc" +"game/settings.gc" +"gfx/mood/mood-tables.gc" +"gfx/mood/mood-tables2.gc" +"gfx/mood/mood.gc" +"gfx/mood/mood-funcs.gc" +"gfx/mood/mood-funcs2.gc" +"gfx/mood/weather-part.gc" +"gfx/mood/time-of-day.gc" +"gfx/sky/sky-data.gc" +"gfx/sky/sky-tng.gc" +"load/load-state.gc" +"level/level-info.gc" +"level/level.gc" +"ui/text.gc" +"spatial-hash/collide-hash.gc" +"collide/collide-probe.gc" +"collide/collide-frag.gc" +"collide/collide-mesh.gc" +"collide/collide-touch.gc" +"collide/collide-edge-grab.gc" +"collide/collide-shape.gc" +"collide/collide-shape-rider.gc" +"collide/collide.gc" +"collide/collide-planes.gc" +"spatial-hash/spatial-hash.gc" +"spatial-hash/actor-hash.gc" +"gfx/merc/merc-death.gc" +"common_objs/water-flow.gc" +"common_objs/water-h.gc" +"camera/camera.gc" +"camera/cam-interface.gc" +"camera/cam-master.gc" +"camera/cam-states.gc" +"camera/cam-states-dbg.gc" +"camera/cam-combiner.gc" +"camera/cam-update.gc" +"geometry/vol-h.gc" +"camera/cam-layout.gc" +"camera/cam-debug.gc" +"camera/cam-start.gc" +"process-drawable/process-drawable.gc" +"ambient/ambient.gc" +"sound/speech.gc" +"level/region.gc" +"anim/fma-sphere.gc" +"util/script.gc" +"common_objs/generic-obs.gc" +"gfx/lightning.gc" +"target/mech_suit/carry-h.gc" +"game/pilot-h.gc" +"target/gun/gun-h.gc" +"target/board/board-h.gc" +"target/darkjak-h.gc" +"target/target-util.gc" +"target/target-part.gc" +"target/gun/gun-part.gc" +"target/collide-reaction-target.gc" +"target/logic-target.gc" +"target/sidekick.gc" +"common_objs/voicebox.gc" +"common_objs/collectables-part.gc" +"debug/debug-part.gc" +"collide/find-nearest.gc" +"game/task/task-arrow.gc" +"common_objs/projectile.gc" +"target/target-handler.gc" +"target/target-anim.gc" +"target/target.gc" +"target/target2.gc" +"target/target-swim.gc" +"target/target-carry.gc" +"target/target-darkjak.gc" +"target/target-death.gc" +"target/target-gun.gc" +"target/gun/gun-util.gc" +"target/gun/gun-blue-shot.gc" +"target/gun/gun-yellow-shot.gc" +"target/gun/gun-red-shot.gc" +"target/gun/gun-dark-shot.gc" +"target/gun/gun-states.gc" +"target/board/board-util.gc" +"target/board/target-board.gc" +"target/board/board-part.gc" +"target/board/board-states.gc" +"target/mech_suit/mech-h.gc" +"debug/menu.gc" +"draw/drawable.gc" +"draw/drawable-group.gc" +"draw/drawable-inline-array.gc" +"draw/drawable-tree.gc" +"gfx/background/prototype.gc" +"collide/main-collide.gc" +"gfx/hw/video.gc" +"game/main.gc" +"collide/collide-cache.gc" +"collide/collide-debug.gc" +"entity/relocate.gc" +"debug/memory-usage.gc" +"entity/entity.gc" +"geometry/path.gc" +"geometry/vol.gc" +"nav/nav-mesh.gc" +"nav/nav-control.gc" +"anim/aligner.gc" +"common_objs/water.gc" +"common_objs/collectables.gc" +"game/task/task-control.gc" +"scene/scene.gc" +"camera/pov-camera.gc" +"common_objs/powerups.gc" +"common_objs/crates.gc" +"ui/hud.gc" +"ui/hud-classes.gc" +"ui/progress/progress-static.gc" +"ui/progress/progress.gc" +"ui/progress/progress-draw.gc" +"gfx/ocean/ocean.gc" +"gfx/ocean/ocean-vu0.gc" +"gfx/ocean/ocean-texture.gc" +"gfx/ocean/ocean-mid.gc" +"gfx/ocean/ocean-transition.gc" +"gfx/ocean/ocean-near.gc" +"ui/minimap.gc" +"ui/bigmap-data.gc" +"ui/bigmap.gc" +"gfx/foreground/eye.gc" +"util/glist-h.gc" +"util/glist.gc" +"debug/anim-tester.gc" +"debug/viewer.gc" +"debug/part-tester.gc" +"debug/editable-h.gc" +"debug/editable.gc" +"debug/editable-player.gc" +"debug/nav/mysql-nav-graph.gc" +"debug/nav/nav-graph-editor.gc" +"debug/sampler.gc" +"debug/default-menu.gc" + + ) + +(cgo "ENGINE.CGO" "engine.gd") + + ;;;;;;;;;;;;;;;;;;;;; ;; ISO Group ;;;;;;;;;;;;;;;;;;;;; diff --git a/goal_src/jak2/kernel/gcommon.gc b/goal_src/jak2/kernel/gcommon.gc index 27ba1a7678..61bc2ad292 100644 --- a/goal_src/jak2/kernel/gcommon.gc +++ b/goal_src/jak2/kernel/gcommon.gc @@ -359,10 +359,10 @@ ) ;; need to forward declare this, we haven't loaded the string library yet. -(define-extern name= (function basic basic symbol)) +(define-extern name= (function object object symbol)) (defun nmember ((arg0 basic) (arg1 object)) - (while (not (or (null? arg1) (name= (the-as basic (car arg1)) arg0))) + (while (not (or (null? arg1) (name= (car arg1) arg0))) (set! arg1 (cdr arg1)) ) (if (not (null? arg1)) diff --git a/goal_src/jak2/kernel/gstring.gc b/goal_src/jak2/kernel/gstring.gc index 57dd3d4246..413a2cebc2 100644 --- a/goal_src/jak2/kernel/gstring.gc +++ b/goal_src/jak2/kernel/gstring.gc @@ -158,6 +158,25 @@ ;; definition for function name= ;; ERROR: function was not converted to expressions. Cannot decompile. +(defun name= ((arg0 object) (arg1 object)) + "Do arg0 and arg1 have the same name? + This can use either strings or symbols" + (cond + ((= arg0 arg1) + ;; Either same symbols, or same string objects, fast check pass! + #t) + ((and (= (rtype-of arg0) string) (= (rtype-of arg1) string)) + (string= (the-as string arg0) (the-as string arg1)) + ) + ((and (= (rtype-of arg0) string) (= (rtype-of arg1) symbol)) + (string= (the-as string arg0) (symbol->string arg1)) + ) + ((and (= (rtype-of arg1) string) (= (rtype-of arg0) symbol)) + (string= (the-as string arg1) (symbol->string arg0)) + ) + ;; no need to check symbol - symbol, that would have passed the first check. + ) + ) (defun copyn-string<-charp ((arg0 string) (arg1 (pointer uint8)) (arg2 int))