From a6f37367d233c23990e32081034b9a16f7ed3a79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 27 Mar 2022 16:45:32 +0200 Subject: [PATCH] Havok: Add more ragdoll header stubs --- lib/hkStubs/CMakeLists.txt | 4 + .../Animation/Rig/hkaBoneAttachment.h | 21 ++ .../Havok/Animation/Animation/Rig/hkaPose.h | 319 ++++++++++++++++++ .../Common/Base/Container/Array/hkArray.h | 12 + .../Havok/Common/Base/Math/Matrix/hkMatrix4.h | 5 + .../Common/Base/Math/Matrix/hkMatrix4f.h | 9 + .../Base/Math/QsTransform/hkQsTransformf.h | 15 + .../Base/Math/QsTransform/hkQsTransformf.inl | 35 ++ .../Common/Base/Math/Vector/hkVector4f.h | 13 + .../Common/Base/Math/Vector/hkVector4f.inl | 9 + lib/hkStubs/Havok/Common/Base/Math/hkMath.h | 2 + .../Havok/Common/Base/Types/hkBaseDefs.h | 3 + .../Havok/Common/Base/Types/hkBaseTypes.h | 2 + 13 files changed, 449 insertions(+) create mode 100644 lib/hkStubs/Havok/Animation/Animation/Rig/hkaBoneAttachment.h create mode 100644 lib/hkStubs/Havok/Animation/Animation/Rig/hkaPose.h create mode 100644 lib/hkStubs/Havok/Common/Base/Math/Matrix/hkMatrix4.h create mode 100644 lib/hkStubs/Havok/Common/Base/Math/Matrix/hkMatrix4f.h diff --git a/lib/hkStubs/CMakeLists.txt b/lib/hkStubs/CMakeLists.txt index 24837775..86e00c61 100644 --- a/lib/hkStubs/CMakeLists.txt +++ b/lib/hkStubs/CMakeLists.txt @@ -8,7 +8,9 @@ add_library(hkStubs OBJECT Havok/Animation/Animation/Mapper/hkaSkeletonMapperData.h Havok/Animation/Animation/Motion/hkaAnimatedReferenceFrame.h Havok/Animation/Animation/Rig/hkaBone.h + Havok/Animation/Animation/Rig/hkaBoneAttachment.h Havok/Animation/Animation/Rig/hkaSkeleton.h + Havok/Animation/Animation/Rig/hkaPose.h Havok/Animation/Physics2012Bridge/Instance/hkaRagdollInstance.h Havok/Common/Base/hkBase.h @@ -27,6 +29,8 @@ add_library(hkStubs OBJECT Havok/Common/Base/Math/Matrix/hkMatrix3.h Havok/Common/Base/Math/Matrix/hkMatrix3f.h Havok/Common/Base/Math/Matrix/hkMatrix3f.inl + Havok/Common/Base/Math/Matrix/hkMatrix4.h + Havok/Common/Base/Math/Matrix/hkMatrix4f.h Havok/Common/Base/Math/Matrix/hkRotation.h Havok/Common/Base/Math/Matrix/hkRotationf.h Havok/Common/Base/Math/Matrix/hkTransform.h diff --git a/lib/hkStubs/Havok/Animation/Animation/Rig/hkaBoneAttachment.h b/lib/hkStubs/Havok/Animation/Animation/Rig/hkaBoneAttachment.h new file mode 100644 index 00000000..c68aca50 --- /dev/null +++ b/lib/hkStubs/Havok/Animation/Animation/Rig/hkaBoneAttachment.h @@ -0,0 +1,21 @@ +#pragma once + +#include + +class hkaBoneAttachment : public hkReferencedObject { +public: + HK_DECLARE_CLASS_ALLOCATOR(hkaBoneAttachment) + HK_DECLARE_REFLECTION() + + inline hkaBoneAttachment() : m_originalSkeletonName(nullptr), m_boneIndex(-1) {} + + HK_FORCE_INLINE explicit hkaBoneAttachment(hkFinishLoadedObjectFlag f) + : hkReferencedObject(f), m_originalSkeletonName(f), m_attachment(f), m_name(f) {} + + // Optional. + hkStringPtr m_originalSkeletonName; + hkMatrix4 m_boneFromAttachment; + hkRefVariant m_attachment; + hkStringPtr m_name; + hkInt16 m_boneIndex; +}; diff --git a/lib/hkStubs/Havok/Animation/Animation/Rig/hkaPose.h b/lib/hkStubs/Havok/Animation/Animation/Rig/hkaPose.h new file mode 100644 index 00000000..695503ec --- /dev/null +++ b/lib/hkStubs/Havok/Animation/Animation/Rig/hkaPose.h @@ -0,0 +1,319 @@ +#pragma once + +#include +#include + +class hkaPose { +public: + HK_DECLARE_CLASS_ALLOCATOR(hkaPose) + + enum PoseSpace { MODEL_SPACE, LOCAL_SPACE }; + + HK_FORCE_INLINE explicit hkaPose(const hkaSkeleton* skeleton); + HK_FORCE_INLINE hkaPose(const hkaSkeleton* skeleton, void* preallocatedMemory); + + HK_FORCE_INLINE static int getRequiredMemorySize(const hkaSkeleton* skeleton); + + hkaPose(PoseSpace space, const hkaSkeleton* skeleton, const hkArrayBase& pose); + hkaPose(PoseSpace space, const hkaSkeleton* skeleton, const hkQsTransform* pose, int numBones); + + enum PropagateOrNot { DONT_PROPAGATE = 0, PROPAGATE = 1 }; + + HK_FORCE_INLINE const hkaSkeleton* getSkeleton() const; + + const hkArray& getSyncedPoseLocalSpace() const; + const hkArray& getSyncedPoseModelSpace() const; + + HK_FORCE_INLINE const hkArray& getFloatSlotValues() const; + + void setPoseLocalSpace(const hkArrayBase& poseLocal); + void setPoseModelSpace(const hkArrayBase& poseModel); + + HK_FORCE_INLINE void setFloatSlotValues(const hkArrayBase& floatSlotValues); + + HK_FORCE_INLINE const hkQsTransform& getBoneLocalSpace(int boneIdx) const; + HK_FORCE_INLINE const hkQsTransform& getBoneModelSpace(int boneIdx) const; + + HK_FORCE_INLINE hkReal getFloatSlotValue(int floatSlotIdx) const; + + HK_FORCE_INLINE void setBoneLocalSpace(int boneIdx, const hkQsTransform& boneLocal); + HK_FORCE_INLINE void setBoneModelSpace(int boneIdx, const hkQsTransform& boneModel, + PropagateOrNot propagateOrNot); + + HK_FORCE_INLINE void setFloatSlotValue(int floatSlotIdx, hkReal value); + + void syncLocalSpace() const; + void syncModelSpace() const; + inline void syncAll() const; + + hkQsTransform& accessBoneLocalSpace(int boneIdx); + hkQsTransform& accessBoneModelSpace(int boneIdx, + PropagateOrNot propagateOrNot = DONT_PROPAGATE); + + hkArray& accessSyncedPoseLocalSpace(); + hkArray& accessSyncedPoseModelSpace(); + + hkArray& accessUnsyncedPoseLocalSpace(); + hkArray& accessUnsyncedPoseModelSpace(); + + HK_FORCE_INLINE hkArray& getFloatSlotValues(); + + void setToReferencePose(); + + void enforceSkeletonConstraintsLocalSpace(); + void enforceSkeletonConstraintsModelSpace(); + + void getModelSpaceAabb(class hkAabb& aabbOut) const; + + inline hkaPose& operator=(const hkaPose& other); + +private: + void init(PoseSpace space, const hkaSkeleton* skeleton, const hkArrayBase& pose); + + using hkaPoseFlag = hkUint32; + + const hkaSkeleton* m_skeleton; + + mutable hkArray m_localPose; + mutable hkArray m_modelPose; + mutable hkArray m_boneFlags; + + mutable hkBool m_modelInSync; + mutable hkBool m_localInSync; + + hkArray m_floatSlotValues; + + enum { + F_BONE_LOCAL_DIRTY = 0x1, + F_BONE_MODEL_DIRTY = 0x2, + F_BONE_INTERNAL_FLAG1 = 0x4, + F_BONE_INTERNAL_FLAG2 = 0x8, + F_BONE_INTERNAL_FLAG3 = 0x10, + }; + + enum { + M_BONE_INTERNAL_FLAGS = + F_BONE_INTERNAL_FLAG1 | F_BONE_INTERNAL_FLAG2 | F_BONE_INTERNAL_FLAG3 + }; + + HK_FORCE_INLINE int isFlagOn(int boneIdx, hkaPoseFlag enumToCheck) const; + HK_FORCE_INLINE void setFlag(int boneIdx, hkaPoseFlag enumToCheck) const; + HK_FORCE_INLINE void clearFlag(int boneIdx, hkaPoseFlag enumToCheck) const; + + HK_FORCE_INLINE int isFlagOnExplicit(hkaPoseFlag flag, hkaPoseFlag enumToCheck) const; + HK_FORCE_INLINE void setFlagExplicit(hkaPoseFlag& flag, hkaPoseFlag enumToCheck) const; + HK_FORCE_INLINE void clearFlagExplicit(hkaPoseFlag& flag, hkaPoseFlag enumToCheck) const; + + HK_FORCE_INLINE void clearInternalFlags() const; + + HK_FORCE_INLINE void makeAllChildrenLocalSpace(int boneIdx) const; + HK_FORCE_INLINE void makeFirstChildrenModelSpace(int boneIdx) const; + + const hkQsTransform& calculateBoneModelSpace(int boneIdx) const; + + void setNonInitializedFlags(); + hkBool checkInternalFlagIsClear(hkaPoseFlag flag) const; + +public: + hkBool checkPoseValidity() const; + hkBool checkPoseTransformsValidity() const; +}; + +inline hkaPose::hkaPose(const hkaSkeleton* skeleton) + : m_skeleton(skeleton), m_modelInSync(false), m_localInSync(false) { + const int numBones = m_skeleton->m_bones.getSize(); + const int numBonesRoundedUp = HK_NEXT_MULTIPLE_OF(4, numBones); + + m_modelPose.reserveExactly(numBonesRoundedUp); + m_localPose.reserveExactly(numBonesRoundedUp); + m_boneFlags.reserveExactly(numBonesRoundedUp); + m_modelPose.setSize(numBones); + m_localPose.setSize(numBones); + m_boneFlags.setSize(numBones); + + const int numSlots = m_skeleton->m_floatSlots.getSize(); + const int numSlotsRoundedUp = HK_NEXT_MULTIPLE_OF(4, numSlots); + m_floatSlotValues.reserveExactly(numSlotsRoundedUp); + m_floatSlotValues.setSize(numSlots, hkReal(0)); +} + +inline hkaPose::hkaPose(const hkaSkeleton* skeleton, void* preallocatedMemory) + : m_skeleton(skeleton), m_localPose(reinterpret_cast(preallocatedMemory), + skeleton->m_bones.getSize(), skeleton->m_bones.getSize()), + m_modelPose(m_localPose.begin() + skeleton->m_bones.getSize(), skeleton->m_bones.getSize(), + skeleton->m_bones.getSize()), + m_boneFlags(reinterpret_cast(m_modelPose.begin() + skeleton->m_bones.getSize()), + skeleton->m_bones.getSize(), skeleton->m_bones.getSize()), + m_modelInSync(false), m_localInSync(false), + m_floatSlotValues( + reinterpret_cast(m_boneFlags.begin() + skeleton->m_bones.getSize()), + skeleton->m_floatSlots.getSize(), + HK_NEXT_MULTIPLE_OF(4, skeleton->m_floatSlots.getSize())) {} + +inline int hkaPose::getRequiredMemorySize(const hkaSkeleton* skeleton) { + const int numBonesRoundedUp = HK_NEXT_MULTIPLE_OF(4, skeleton->m_bones.getSize()); + + const int floatSizeRoundedUp = HK_NEXT_MULTIPLE_OF(4, skeleton->m_floatSlots.getSize()); + + const int totalSize = + numBonesRoundedUp * (2 * hkSizeOf(hkQsTransform) + hkSizeOf(hkaPoseFlag)) + + floatSizeRoundedUp * hkSizeOf(hkReal); + + return totalSize; +} + +inline const hkaSkeleton* hkaPose::getSkeleton() const { + return m_skeleton; +} + +inline const hkArray& hkaPose::getFloatSlotValues() const { + return m_floatSlotValues; +} + +inline void hkaPose::setFloatSlotValues(const hkArrayBase& floatSlotValues) { + m_floatSlotValues = floatSlotValues; +} + +inline const hkQsTransform& hkaPose::getBoneLocalSpace(int boneIdx) const { + if (!isFlagOn(boneIdx, F_BONE_LOCAL_DIRTY)) + return m_localPose[boneIdx]; + + const hkQsTransform& modelFromBone = m_modelPose[boneIdx]; + + const hkInt16 parentIdx = m_skeleton->m_parentIndices[boneIdx]; + + if (parentIdx != -1) { + const hkQsTransform& modelFromParent = getBoneModelSpace(parentIdx); + m_localPose[boneIdx].setMulInverseMul(modelFromParent, modelFromBone); + } else { + m_localPose[boneIdx] = modelFromBone; + } + + clearFlag(boneIdx, F_BONE_LOCAL_DIRTY); + + return m_localPose[boneIdx]; +} + +inline const hkQsTransform& hkaPose::getBoneModelSpace(int boneIdx) const { + if (isFlagOn(boneIdx, F_BONE_MODEL_DIRTY)) + return calculateBoneModelSpace(boneIdx); + return m_modelPose[boneIdx]; +} + +inline hkReal hkaPose::getFloatSlotValue(int floatSlotIdx) const { + return m_floatSlotValues[floatSlotIdx]; +} + +inline void hkaPose::setBoneLocalSpace(int boneIdx, const hkQsTransform& boneLocal) { + makeAllChildrenLocalSpace(boneIdx); + m_localPose[boneIdx] = boneLocal; + m_boneFlags[boneIdx] = F_BONE_MODEL_DIRTY; + m_modelInSync = false; +} + +inline void hkaPose::setBoneModelSpace(int boneIdx, const hkQsTransform& boneModel, + hkaPose::PropagateOrNot propagateOrNot) { + if (propagateOrNot) + makeAllChildrenLocalSpace(boneIdx); + else + makeFirstChildrenModelSpace(boneIdx); + + m_modelPose[boneIdx] = boneModel; + m_boneFlags[boneIdx] = F_BONE_LOCAL_DIRTY; + m_localInSync = false; +} + +inline void hkaPose::setFloatSlotValue(int floatSlotIdx, hkReal value) { + m_floatSlotValues[floatSlotIdx] = value; +} + +inline void hkaPose::syncAll() const { + syncLocalSpace(); + syncModelSpace(); +} + +inline hkArray& hkaPose::getFloatSlotValues() { + return m_floatSlotValues; +} + +inline hkaPose& hkaPose::operator=(const hkaPose& other) { + m_skeleton = other.m_skeleton; + m_localPose = other.m_localPose; + m_modelPose = other.m_modelPose; + m_boneFlags = other.m_boneFlags; + m_modelInSync = other.m_modelInSync; + m_localInSync = other.m_localInSync; + m_floatSlotValues = other.m_floatSlotValues; + + return *this; +} + +inline int hkaPose::isFlagOn(int boneIdx, hkaPose::hkaPoseFlag enumToCheck) const { + return m_boneFlags[boneIdx] & enumToCheck; +} + +inline void hkaPose::setFlag(int boneIdx, hkaPose::hkaPoseFlag enumToCheck) const { + m_boneFlags[boneIdx] |= enumToCheck; +} + +inline void hkaPose::clearFlag(int boneIdx, hkaPose::hkaPoseFlag enumToCheck) const { + m_boneFlags[boneIdx] &= static_cast(~enumToCheck); +} + +inline int hkaPose::isFlagOnExplicit(hkaPose::hkaPoseFlag flag, + hkaPose::hkaPoseFlag enumToCheck) const { + return int(flag & enumToCheck); +} + +inline void hkaPose::setFlagExplicit(hkaPose::hkaPoseFlag& flag, + hkaPose::hkaPoseFlag enumToCheck) const { + flag |= enumToCheck; +} + +inline void hkaPose::clearFlagExplicit(hkaPose::hkaPoseFlag& flag, + hkaPose::hkaPoseFlag enumToCheck) const { + flag &= static_cast(~enumToCheck); +} + +inline void hkaPose::clearInternalFlags() const { + const int numBones = m_boneFlags.getSize(); + for (int i = 0; i < numBones; ++i) + m_boneFlags[i] &= (~M_BONE_INTERNAL_FLAGS); +} + +inline void hkaPose::makeAllChildrenLocalSpace(int boneIdx) const { + const int numBones = m_skeleton->m_bones.getSize(); + + setFlag(boneIdx, F_BONE_INTERNAL_FLAG1); + + for (int i = boneIdx + 1; i < numBones; ++i) { + const hkInt16 parentId = m_skeleton->m_parentIndices[i]; + if (parentId != -1 && isFlagOn(parentId, F_BONE_INTERNAL_FLAG1)) { + getBoneLocalSpace(i); + setFlag(i, F_BONE_INTERNAL_FLAG1); + m_modelInSync = false; + } + } + + for (int i = boneIdx + 1; i < numBones; ++i) { + hkaPoseFlag f = m_boneFlags[i]; + if (isFlagOnExplicit(f, F_BONE_INTERNAL_FLAG1)) { + setFlagExplicit(f, F_BONE_MODEL_DIRTY); + clearFlagExplicit(f, F_BONE_INTERNAL_FLAG1); + m_boneFlags[i] = f; + } + } +} + +inline void hkaPose::makeFirstChildrenModelSpace(int boneIdx) const { + const int numBones = m_skeleton->m_bones.getSize(); + + for (int i = boneIdx + 1; i < numBones; ++i) { + const hkInt16 parentId = m_skeleton->m_parentIndices[i]; + if (parentId == boneIdx) { + getBoneModelSpace(i); // sync model + m_boneFlags[i] = F_BONE_LOCAL_DIRTY; + m_localInSync = false; + } + } +} diff --git a/lib/hkStubs/Havok/Common/Base/Container/Array/hkArray.h b/lib/hkStubs/Havok/Common/Base/Container/Array/hkArray.h index a4afe8d6..ba542278 100644 --- a/lib/hkStubs/Havok/Common/Base/Container/Array/hkArray.h +++ b/lib/hkStubs/Havok/Common/Base/Container/Array/hkArray.h @@ -122,6 +122,8 @@ public: HK_FORCE_INLINE void clearAndDeallocate(); HK_FORCE_INLINE void pushBack(const T& e); + HK_FORCE_INLINE hkResult reserve(int size); + HK_FORCE_INLINE hkResult reserveExactly(int size); HK_FORCE_INLINE void setSize(int size); HK_FORCE_INLINE void setSize(int size, const T& fill); @@ -425,6 +427,16 @@ inline void hkArray::setSize(int size, const T& fill) { this->_setSize(AllocatorType().get(), size, fill); } +template +inline hkResult hkArray::reserve(int size) { + return this->_reserve(AllocatorType().get(), size); +} + +template +inline hkResult hkArray::reserveExactly(int size) { + return this->_reserveExactly(AllocatorType().get(), size); +} + template inline hkInplaceArray::hkInplaceArray(int size) : hkArray(m_storage, size, N) {} diff --git a/lib/hkStubs/Havok/Common/Base/Math/Matrix/hkMatrix4.h b/lib/hkStubs/Havok/Common/Base/Math/Matrix/hkMatrix4.h new file mode 100644 index 00000000..a0917d8e --- /dev/null +++ b/lib/hkStubs/Havok/Common/Base/Math/Matrix/hkMatrix4.h @@ -0,0 +1,5 @@ +#pragma once + +#include + +using hkMatrix4 = hkMatrix4f; diff --git a/lib/hkStubs/Havok/Common/Base/Math/Matrix/hkMatrix4f.h b/lib/hkStubs/Havok/Common/Base/Math/Matrix/hkMatrix4f.h new file mode 100644 index 00000000..677b2164 --- /dev/null +++ b/lib/hkStubs/Havok/Common/Base/Math/Matrix/hkMatrix4f.h @@ -0,0 +1,9 @@ +#pragma once + +class hkMatrix4f { +public: + hkVector4f m_col0; + hkVector4f m_col1; + hkVector4f m_col2; + hkVector4f m_col3; +}; diff --git a/lib/hkStubs/Havok/Common/Base/Math/QsTransform/hkQsTransformf.h b/lib/hkStubs/Havok/Common/Base/Math/QsTransform/hkQsTransformf.h index 8a602afc..0955f489 100644 --- a/lib/hkStubs/Havok/Common/Base/Math/QsTransform/hkQsTransformf.h +++ b/lib/hkStubs/Havok/Common/Base/Math/QsTransform/hkQsTransformf.h @@ -36,6 +36,21 @@ public: void setFromTransform(const hkQTransformf& qt); void copyToTransform(hkTransformf& transformOut) const; + HK_FORCE_INLINE void setInverse(const hkQsTransformf& t); + + HK_FORCE_INLINE void setMul(const hkQsTransformf& t1, const hkQsTransformf& t2); + + HK_FORCE_INLINE void setMulScaled(const hkQsTransformf& t1, const hkQsTransformf& t2); + + /// this = t1^-1 * t2 + HK_FORCE_INLINE void setMulInverseMul(const hkQsTransformf& t1, const hkQsTransformf& t2); + + /// this = t1 * t2^-1 + HK_FORCE_INLINE void setMulMulInverse(const hkQsTransformf& t1, const hkQsTransformf& t2); + + /// this *= b + HK_FORCE_INLINE void setMulEq(const hkQsTransformf& b); + hkVector4f m_translation; hkQuaternionf m_rotation; hkVector4f m_scale; diff --git a/lib/hkStubs/Havok/Common/Base/Math/QsTransform/hkQsTransformf.inl b/lib/hkStubs/Havok/Common/Base/Math/QsTransform/hkQsTransformf.inl index 886d0652..4d8401f2 100644 --- a/lib/hkStubs/Havok/Common/Base/Math/QsTransform/hkQsTransformf.inl +++ b/lib/hkStubs/Havok/Common/Base/Math/QsTransform/hkQsTransformf.inl @@ -47,3 +47,38 @@ inline void hkQsTransformf::setZero() { m_rotation.m_vec.setZero(); m_scale.setZero(); } + +inline void hkQsTransformf::setInverse(const hkQsTransformf& t) { + m_translation.setRotatedInverseDir(t.m_rotation, t.m_translation); + m_translation.setNeg<4>(m_translation); + m_rotation.setInverse(t.m_rotation); + + m_scale.setReciprocal(t.m_scale); + + m_scale.zeroComponent<3>(); +} + +inline void hkQsTransformf::setMul(const hkQsTransformf& t1, const hkQsTransformf& t2) { + hkVector4f extraTrans; + extraTrans._setRotatedDir(t1.m_rotation, t2.m_translation); + m_translation.setAdd(t1.m_translation, extraTrans); + m_rotation.setMul(t1.m_rotation, t2.m_rotation); + + m_scale.setMul(t1.m_scale, t2.m_scale); +} + +inline void hkQsTransformf::setMulInverseMul(const hkQsTransformf& t1, const hkQsTransformf& t2) { + hkQsTransformf inv; + inv.setInverse(t1); + setMul(inv, t2); +} + +inline void hkQsTransformf::setMulMulInverse(const hkQsTransformf& t1, const hkQsTransformf& t2) { + hkQsTransformf inv; + inv.setInverse(t2); + setMul(t1, inv); +} + +inline void hkQsTransformf::setMulEq(const hkQsTransformf& b) { + setMul(*this, b); +} diff --git a/lib/hkStubs/Havok/Common/Base/Math/Vector/hkVector4f.h b/lib/hkStubs/Havok/Common/Base/Math/Vector/hkVector4f.h index 699d1e93..c9bd6b97 100644 --- a/lib/hkStubs/Havok/Common/Base/Math/Vector/hkVector4f.h +++ b/lib/hkStubs/Havok/Common/Base/Math/Vector/hkVector4f.h @@ -27,6 +27,9 @@ public: HK_FORCE_INLINE void setAll(hkFloat32 x); HK_FORCE_INLINE void setAll(hkSimdFloat32Parameter x); HK_FORCE_INLINE void setZero(); + template + HK_FORCE_INLINE void zeroComponent(); + HK_FORCE_INLINE void zeroComponent(int i); // ========== Vector operations @@ -116,7 +119,17 @@ public: // ========== Matrix operations (out-of-line) void setRotatedDir(const hkMatrix3f& a, hkVector4fParameter b); + void setRotatedInverseDir(const hkMatrix3f& a, hkVector4fParameter b); void setTransformedPos(const hkTransformf& a, const hkVector4f& pos); + void setTransformedInversePos(const hkTransformf& a, hkVector4fParameter b); + + void setRotatedDir(hkQuaternionfParameter quat, hkVector4fParameter direction); + void setRotatedInverseDir(hkQuaternionfParameter quat, hkVector4fParameter direction); + void setTransformedPos(const hkQsTransformf& a, hkVector4fParameter b); + void setTransformedInversePos(const hkQsTransformf& a, hkVector4fParameter b); + + void setTransformedPos(const hkQTransformf& a, hkVector4fParameter b); + void setTransformedInversePos(const hkQTransformf& a, hkVector4fParameter b); // ========== Matrix operations (inline) diff --git a/lib/hkStubs/Havok/Common/Base/Math/Vector/hkVector4f.inl b/lib/hkStubs/Havok/Common/Base/Math/Vector/hkVector4f.inl index a4ad8c2a..8356223a 100644 --- a/lib/hkStubs/Havok/Common/Base/Math/Vector/hkVector4f.inl +++ b/lib/hkStubs/Havok/Common/Base/Math/Vector/hkVector4f.inl @@ -63,6 +63,15 @@ inline void hkVector4f::setZero() { setAll(0); } +template +inline void hkVector4f::zeroComponent() { + v[I] = 0; +} + +inline void hkVector4f::zeroComponent(int i) { + v[i] = 0; +} + inline void hkVector4f::add(hkVector4fParameter a) { setAdd(*this, a); } diff --git a/lib/hkStubs/Havok/Common/Base/Math/hkMath.h b/lib/hkStubs/Havok/Common/Base/Math/hkMath.h index 055af896..6c310de7 100644 --- a/lib/hkStubs/Havok/Common/Base/Math/hkMath.h +++ b/lib/hkStubs/Havok/Common/Base/Math/hkMath.h @@ -18,6 +18,7 @@ class hkRotationf; class hkTransformf; class hkQTransformf; class hkQsTransformf; +class hkMatrix4f; // Type aliases using hkVector4fParameter = const hkVector4f&; @@ -34,6 +35,7 @@ using hkQuaternionfParameter = const hkQuaternionf&; #include #include #include +#include // Implementations #include diff --git a/lib/hkStubs/Havok/Common/Base/Types/hkBaseDefs.h b/lib/hkStubs/Havok/Common/Base/Types/hkBaseDefs.h index dc0db329..30d53aba 100644 --- a/lib/hkStubs/Havok/Common/Base/Types/hkBaseDefs.h +++ b/lib/hkStubs/Havok/Common/Base/Types/hkBaseDefs.h @@ -9,3 +9,6 @@ #define HK_RESTRICT __restrict #define HK_MAX_NUM_THREADS 12 + +#define HK_NEXT_MULTIPLE_OF(ALIGNMENT, VALUE) \ + (((VALUE) + ((ALIGNMENT)-1)) & (~((ALIGNMENT) + (VALUE)*0 - 1))) diff --git a/lib/hkStubs/Havok/Common/Base/Types/hkBaseTypes.h b/lib/hkStubs/Havok/Common/Base/Types/hkBaseTypes.h index c6719c75..d2e63472 100644 --- a/lib/hkStubs/Havok/Common/Base/Types/hkBaseTypes.h +++ b/lib/hkStubs/Havok/Common/Base/Types/hkBaseTypes.h @@ -212,6 +212,8 @@ public: int m_finishing = 0; }; +#define hkSizeOf(A) int(sizeof(A)) + HK_FORCE_INLINE hkLong hkGetByteOffset(const void* base, const void* pntr) { return hkLong(pntr) - hkLong(base); }