Havok: Add hkpWorldCinfo

data/uking_functions.csv

@@ -78787,7 +78787,7 @@ Address,Quality,Size,Name
 0x0000007100e71764,U,001160,sinitHorseStrings
 0x0000007100e71bec,U,000604,
 0x0000007100e71e48,U,000088,
-0x0000007100e71ea0,U,000004,nullsub_3986
+0x0000007100e71ea0,O,000004,_ZN12hkBaseObject32__first_virtual_table_function__Ev
 0x0000007100e71ea4,U,000204,
 0x0000007100e71f70,U,000092,
 0x0000007100e71fcc,U,000008,
@@ -83582,7 +83582,7 @@ Address,Quality,Size,Name
 0x0000007100fabcdc,O,000008,_ZNK4ksys4phys11CapsuleBody8getShapeEv
 0x0000007100fabce4,U,000252,
 0x0000007100fabde0,U,000160,
-0x0000007100fabe80,m,000192,_ZN4ksys4phys11CapsuleBody14sub_7100FABE80EPN4sead7Vector3IfEES5_RK9hkVector4
+0x0000007100fabe80,m,000192,_ZN4ksys4phys11CapsuleBody14sub_7100FABE80EPN4sead7Vector3IfEES5_RK10hkVector4f
 0x0000007100fabf40,U,000204,
 0x0000007100fac00c,U,000092,
 0x0000007100fac068,U,000008,
@@ -95462,13 +95462,13 @@ Address,Quality,Size,Name
 0x00000071012b3ce8,U,000052,
 0x00000071012b3d1c,U,000104,
 0x00000071012b3d84,U,000104,
-0x00000071012b3dec,U,000356,
+0x00000071012b3dec,O,000356,_ZN13hkpWorldCinfoD2Ev
 0x00000071012b3f50,U,000096,
 0x00000071012b3fb0,U,000024,
 0x00000071012b3fc8,U,000024,
 0x00000071012b3fe0,U,000112,
 0x00000071012b4050,U,000092,
-0x00000071012b40ac,U,000088,
+0x00000071012b40ac,O,000088,_ZN13hkpWorldCinfoD0Ev
 0x00000071012b4104,U,000032,
 0x00000071012b4124,U,000252,
 0x00000071012b4220,U,000084,
@@ -105210,10 +105210,10 @@ Address,Quality,Size,Name
 0x0000007101607d74,U,000092,
 0x0000007101607dd0,U,000068,
 0x0000007101607e14,U,000232,
-0x0000007101607efc,L,000344,hkpWorldCinfo::hkpWorldCinfo
+0x0000007101607efc,L,000344,_ZN13hkpWorldCinfoC1Ev
-0x0000007101608054,U,000032,
+0x0000007101608054,L,000032,_ZN13hkpWorldCinfo22setBroadPhaseWorldSizeEf
-0x0000007101608074,U,000244,
+0x0000007101608074,L,000244,_ZN13hkpWorldCinfo15setupSolverInfoENS_10SolverTypeE
-0x0000007101608168,U,000084,
+0x0000007101608168,L,000084,_ZN13hkpWorldCinfoC1E24hkFinishLoadedObjectFlag
 0x00000071016081bc,L,000968,hkpWorldOperationUtil::updateEntityBP
 0x0000007101608584,U,000452,
 0x0000007101608748,U,000432,

lib/hkStubs/.clang-tidy

@@ -1,3 +1,3 @@
 ---
 InheritParentConfig: true
-Checks: "-modernize-use-equals-default"
+Checks: "-modernize-use-equals-default,-cppcoreguidelines-pro-type-member-init"

lib/hkStubs/CMakeLists.txt

@@ -3,10 +3,13 @@ project(hkStubs CXX ASM)
 add_library(hkStubs OBJECT
   Havok/Common/Base/hkBase.h
 
+  Havok/Common/Base/Container/hkContainerAllocators.h
+  Havok/Common/Base/Container/Array/hkArray.h
   Havok/Common/Base/Container/String/hkStringPtr.h
 
   Havok/Common/Base/Math/hkMath.h
   Havok/Common/Base/Math/Vector/hkVector4.h
+  Havok/Common/Base/Math/Vector/hkVector4f.h
 
   Havok/Common/Base/Memory/Allocator/hkMemoryAllocator.h
   Havok/Common/Base/Memory/Allocator/Lifo/hkLifoAllocator.h
@@ -21,17 +24,30 @@ add_library(hkStubs OBJECT
 
   Havok/Common/Base/Types/hkBaseDefs.h
   Havok/Common/Base/Types/hkBaseTypes.h
+  Havok/Common/Base/Types/hkRefPtr.h
+  Havok/Common/Base/Types/Geometry/Aabb/hkAabb.h
 
-  Havok/Physics/Collide/Shape/hkpShape.h
+  Havok/Physics2012/Collide/Filter/hkpCollidableCollidableFilter.h
-  Havok/Physics/Collide/Shape/Convex/hkpConvexShape.h
+  Havok/Physics2012/Collide/Filter/hkpCollisionFilter.h
-  Havok/Physics/Collide/Shape/Convex/Capsule/hkpCapsuleShape.h
+  Havok/Physics2012/Collide/Filter/hkpConvexListFilter.h
-  Havok/Physics/Collide/Shape/HeightField/hkpSphereRepShape.h
+  Havok/Physics2012/Collide/Filter/hkpRayCollidableFilter.h
+  Havok/Physics2012/Collide/Filter/hkpShapeCollectionFilter.h
+  Havok/Physics2012/Collide/Shape/hkpShape.h
+  Havok/Physics2012/Collide/Shape/hkpShapeBase.h
+  Havok/Physics2012/Collide/Shape/Convex/hkpConvexShape.h
+  Havok/Physics2012/Collide/Shape/Convex/Capsule/hkpCapsuleShape.h
+  Havok/Physics2012/Collide/Shape/HeightField/hkpSphereRepShape.h
+  Havok/Physics2012/Collide/Shape/Query/hkpRayShapeCollectionFilter.h
 
-  Havok/Physics/Dynamics/Entity/hkpEntity.h
+  Havok/Physics2012/Dynamics/Entity/hkpEntity.h
-  Havok/Physics/Dynamics/Entity/hkpRigidBody.h
+  Havok/Physics2012/Dynamics/Entity/hkpRigidBody.h
-  Havok/Physics/Dynamics/World/hkpWorld.cpp
+  Havok/Physics2012/Dynamics/World/hkpWorld.cpp
-  Havok/Physics/Dynamics/World/hkpWorld.h
+  Havok/Physics2012/Dynamics/World/hkpWorld.h
-  Havok/Physics/Dynamics/World/hkpWorldEntity.h
+  Havok/Physics2012/Dynamics/World/hkpWorldCinfo.cpp
+  Havok/Physics2012/Dynamics/World/hkpWorldCinfo.h
+  Havok/Physics2012/Dynamics/World/hkpWorldEntity.h
+  Havok/Physics2012/Dynamics/World/Memory/hkpWorldMemoryAvailableWatchDog.h
+  Havok/Physics2012/Dynamics/World/Memory/Default/hkpDefaultWorldMemoryWatchDog.h
 )
 
 target_compile_options(hkStubs PRIVATE -fno-exceptions)

lib/hkStubs/Havok/Common/Base/Container/Array/hkArray.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <Havok/Common/Base/Container/hkContainerAllocators.h>
+#include <Havok/Common/Base/Types/hkBaseDefs.h>
+#include <Havok/Common/Base/Types/hkBaseTypes.h>
+
+/// Base class for hkArray (a std::vector-like container).
+// FIXME: incomplete
+template <typename T>
+class hkArrayBase {
+public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkArrayBase<T>)
+
+    enum : int {
+        CAPACITY_MASK = 0x3FFFFFFF,
+        FLAG_MASK = 0xC0000000,
+        DONT_DEALLOCATE_FLAG = 0x80000000,
+    };
+
+    HK_FORCE_INLINE hkArrayBase();
+    explicit hkArrayBase(hkFinishLoadedObjectFlag f) {}
+
+    HK_FORCE_INLINE ~hkArrayBase();
+
+    hkArrayBase(const hkArrayBase&) = delete;
+    auto operator=(const hkArrayBase&) = delete;
+
+protected:
+    T* m_data;
+    int m_size;
+    int m_capacityAndFlags;
+};
+
+/// A dynamically resizable array, similar to std::vector.
+// FIXME: incomplete
+template <typename T, typename Allocator = hkContainerHeapAllocator>
+class hkArray : public hkArrayBase<T> {
+public:
+    using AllocatorType = Allocator;
+
+    HK_FORCE_INLINE hkArray() = default;
+    explicit hkArray(hkFinishLoadedObjectFlag f) : hkArrayBase<T>(f) {}
+
+    HK_FORCE_INLINE ~hkArray();
+
+    HK_FORCE_INLINE hkArray& operator=(const hkArrayBase<T>& other);
+    HK_FORCE_INLINE hkArray& operator=(const hkArray& other);
+
+protected:
+    HK_FORCE_INLINE hkArray(const hkArray& other);
+};
+
+template <typename T>
+inline hkArrayBase<T>::hkArrayBase()
+    : m_data(nullptr), m_size(0), m_capacityAndFlags(DONT_DEALLOCATE_FLAG) {}
+
+template <typename T>
+inline hkArrayBase<T>::~hkArrayBase() {
+    // Assert non-POD element destruction
+}

lib/hkStubs/Havok/Common/Base/Container/hkContainerAllocators.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <Havok/Common/Base/Memory/Allocator/hkMemoryAllocator.h>
+#include <Havok/Common/Base/Memory/Router/hkMemoryRouter.h>
+
+struct hkContainerHeapAllocator {
+    HK_DECLARE_CLASS_ALLOCATOR(hkContainerHeapAllocator)
+
+    struct Allocator : hkMemoryAllocator {
+        HK_DECLARE_CLASS_ALLOCATOR(Allocator)
+
+        void* blockAlloc(int numBytes) override;
+        void blockFree(void* p, int numBytes) override;
+        void* bufAlloc(int& reqNumBytesInOut) override;
+        void bufFree(void* p, int numBytes) override;
+        void* bufRealloc(void* pold, int oldNumBytes, int& reqNumBytesInOut) override;
+        void getMemoryStatistics(MemoryStatistics& u) const override;
+        int getAllocatedSize(const void* obj, int nbytes) const override;
+    };
+
+    static Allocator s_alloc;
+    static hkMemoryAllocator& get() { return s_alloc; }
+};

lib/hkStubs/Havok/Common/Base/Math/Vector/hkVector4.h

@@ -1,15 +1,5 @@
 #pragma once
 
-class hkVector4 {
+#include <Havok/Common/Base/Math/Vector/hkVector4f.h>
-public:
-    hkVector4() {}
-    hkVector4(hkReal x, hkReal y, hkReal z, hkReal w = 0) {
-        v[0] = x;
-        v[1] = y;
-        v[2] = z;
-        v[3] = w;
-    }
-    m128 v;
 
-    void sub_7100FABE80(const hkVector4&, const hkVector4&);
+using hkVector4 = hkVector4f;
-};

lib/hkStubs/Havok/Common/Base/Math/Vector/hkVector4f.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <Havok/Common/Base/Memory/Router/hkMemoryRouter.h>
+#include <Havok/Common/Base/Types/hkBaseDefs.h>
+#include <Havok/Common/Base/Types/hkBaseTypes.h>
+
+class hkVector4f {
+public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkVector4f)
+
+    HK_FORCE_INLINE hkVector4f() {}
+    HK_FORCE_INLINE hkVector4f(hkReal x, hkReal y, hkReal z, hkReal w = 0);
+
+    // This prevents hkVector4f from being passed in registers.
+    // NOLINTNEXTLINE(modernize-use-equals-default)
+    HK_FORCE_INLINE hkVector4f(const hkVector4f& other) : v(other.v) {}
+
+    HK_FORCE_INLINE void set(hkReal x, hkReal y, hkReal z, hkReal w = 0);
+    HK_FORCE_INLINE void setAll(hkReal x);
+
+    void sub_7100FABE80(const hkVector4f&, const hkVector4f&);
+
+    m128 v;
+};
+
+inline hkVector4f::hkVector4f(hkReal x, hkReal y, hkReal z, hkReal w) {
+    v[0] = x;
+    v[1] = y;
+    v[2] = z;
+    v[3] = w;
+}
+
+inline void hkVector4f::set(hkReal x, hkReal y, hkReal z, hkReal w) {
+    v[0] = x;
+    v[1] = y;
+    v[2] = z;
+    v[3] = w;
+}
+
+inline void hkVector4f::setAll(hkReal x) {
+    v = {x, x, x, x};
+}

lib/hkStubs/Havok/Common/Base/Types/Geometry/Aabb/hkAabb.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <Havok/Common/Base/Math/Vector/hkVector4.h>
+#include <Havok/Common/Base/Memory/Router/hkMemoryRouter.h>
+
+/// Axis aligned bounding box
+// FIXME: incomplete
+class hkAabb {
+public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkAabb)
+
+    hkAabb() {}
+    HK_FORCE_INLINE hkAabb(const hkVector4& min, const hkVector4& max) : m_min(min), m_max(max) {}
+
+    hkVector4 m_min;
+    hkVector4 m_max;
+};

lib/hkStubs/Havok/Common/Base/Types/hkBaseTypes.h

@@ -71,6 +71,26 @@ private:
     hkInt16 m_value;
 };
 
+class hkBool {
+public:
+    HK_ALWAYS_INLINE hkBool() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    HK_FORCE_INLINE hkBool(bool b) : m_bool(static_cast<char>(b)) {}
+
+    HK_FORCE_INLINE explicit operator bool() const { return m_bool != 0; }
+
+    HK_FORCE_INLINE hkBool& operator=(bool e) {
+        m_bool = static_cast<char>(e);
+        return *this;
+    }
+
+    HK_FORCE_INLINE hkBool operator==(bool e) const { return (m_bool != 0) == e; }
+    HK_FORCE_INLINE hkBool operator!=(bool e) const { return (m_bool != 0) != e; }
+
+private:
+    char m_bool;
+};
+
 /// For storing an enum with a particular storage size when specifying the underlying type of the
 /// enum is not an option.
 template <typename Enum, typename Storage>

lib/hkStubs/Havok/Common/Base/Types/hkRefPtr.h

@@ -0,0 +1,143 @@
+#pragma once
+
+#include <Havok/Common/Base/Object/hkReferencedObject.h>
+#include <Havok/Common/Base/Types/hkBaseDefs.h>
+#include <utility>
+
+/// Owning reference. Assign to a hkRefPtr as soon as possible.
+/// @warning This will NOT automatically destruct the contained object.
+template <typename T>
+class hkRefNew {
+public:
+    hkRefNew(T* ptr) : m_ptr(ptr) {}  // NOLINT(google-explicit-constructor)
+
+    hkRefNew(const hkRefNew&) = delete;
+    auto operator=(const hkRefNew&) = delete;
+
+    T* release() { return std::exchange(m_ptr, nullptr); }
+
+private:
+    T* m_ptr;
+};
+
+/// A simple reference counting pointer intended to be used with hkReferencedObjects.
+template <typename T>
+class hkRefPtr {
+public:
+    /// Default constructor. Initializes the pointer to nullptr.
+    HK_FORCE_INLINE hkRefPtr();
+    /// Copy constructor. Increments the reference count.
+    HK_FORCE_INLINE hkRefPtr(const hkRefPtr& other);
+    HK_FORCE_INLINE hkRefPtr(T* ptr);  // NOLINT(google-explicit-constructor)
+    /// "Move" constructor. Steals the reference from ptr.
+    HK_FORCE_INLINE hkRefPtr(hkRefNew<T> ptr);  // NOLINT(google-explicit-constructor)
+
+    HK_FORCE_INLINE explicit hkRefPtr(hkFinishLoadedObjectFlag);
+
+    /// Decrements the reference count.
+    HK_FORCE_INLINE ~hkRefPtr();
+
+    HK_FORCE_INLINE hkRefPtr& operator=(const hkRefPtr& other);
+    HK_FORCE_INLINE hkRefPtr& operator=(T* ptr);
+    HK_FORCE_INLINE hkRefPtr& operator=(hkRefNew<T> ptr);
+
+    HK_FORCE_INLINE T* val() const;
+    HK_FORCE_INLINE T* operator->() const;
+    HK_FORCE_INLINE operator T*() const;  // NOLINT(google-explicit-constructor)
+
+    HK_FORCE_INLINE void setAndDontIncrementRefCount(T* ptr);
+    HK_FORCE_INLINE void unsetAndDontDecrementRefCount();
+
+private:
+    void addReference() const {
+        if (m_ptr)
+            m_ptr->addReference();
+    }
+
+    void removeReference() const {
+        if (m_ptr)
+            m_ptr->removeReference();
+    }
+
+    T* m_ptr;
+};
+
+template <typename T>
+inline hkRefPtr<T>::hkRefPtr() : m_ptr(nullptr) {}
+
+template <typename T>
+inline hkRefPtr<T>::hkRefPtr(const hkRefPtr& other) {
+    other.addReference();
+    m_ptr = other.m_ptr;
+}
+
+template <typename T>
+inline hkRefPtr<T>::hkRefPtr(T* ptr) {
+    if (ptr)
+        ptr->addReference();
+    m_ptr = ptr;
+}
+
+template <typename T>
+inline hkRefPtr<T>::hkRefPtr(hkRefNew<T> ptr) : m_ptr(ptr.release()) {}
+
+template <typename T>
+inline hkRefPtr<T>::hkRefPtr(hkFinishLoadedObjectFlag) {}
+
+template <typename T>
+inline hkRefPtr<T>::~hkRefPtr() {
+    removeReference();
+    m_ptr = nullptr;
+}
+
+template <typename T>
+// NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
+inline hkRefPtr<T>& hkRefPtr<T>::operator=(const hkRefPtr& other) {
+    other.addReference();
+    removeReference();
+    m_ptr = other.m_ptr;
+    return *this;
+}
+
+template <typename T>
+inline hkRefPtr<T>& hkRefPtr<T>::operator=(T* ptr) {
+    if (ptr)
+        ptr->addReference();
+    removeReference();
+    m_ptr = ptr;
+    return *this;
+}
+
+template <typename T>
+inline hkRefPtr<T>& hkRefPtr<T>::operator=(hkRefNew<T> ptr) {
+    removeReference();
+    m_ptr = ptr.release();
+    return *this;
+}
+
+template <typename T>
+inline T* hkRefPtr<T>::val() const {
+    return m_ptr;
+}
+
+template <typename T>
+inline T* hkRefPtr<T>::operator->() const {
+    return val();
+}
+
+template <typename T>
+inline hkRefPtr<T>::operator T*() const {
+    return val();
+}
+
+template <typename T>
+inline void hkRefPtr<T>::setAndDontIncrementRefCount(T* ptr) {
+    if (m_ptr && m_ptr != ptr)
+        m_ptr->removeReference();
+    m_ptr = ptr;
+}
+
+template <typename T>
+inline void hkRefPtr<T>::unsetAndDontDecrementRefCount() {
+    m_ptr = nullptr;
+}

lib/hkStubs/Havok/Physics/Collide/Shape/Convex/hkpConvexShape.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <Havok/Physics/Collide/Shape/hkpShape.h>
-
-// TODO
-class hkpConvexShape {};

lib/hkStubs/Havok/Physics/Collide/Shape/HeightField/hkpSphereRepShape.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include <Havok/Physics/Collide/Shape/hkpShape.h>
-
-// TODO
-class hkpSphereRepShape {};

lib/hkStubs/Havok/Physics/Dynamics/World/hkpWorld.cpp

@@ -1,3 +0,0 @@
-#include "Havok/Physics/Dynamics/World/hkpWorld.h"
-
-hkpWorld::hkpWorld() {}

lib/hkStubs/Havok/Physics2012/Collide/Filter/hkpCollidableCollidableFilter.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <Havok/Common/Base/Types/hkBaseTypes.h>
+
+class hkpCollidable;
+
+class hkpCollidableCollidableFilter {
+public:
+    virtual ~hkpCollidableCollidableFilter() = default;
+
+    /// Whether the two objects can collide.
+    virtual hkBool isCollisionEnabled(const hkpCollidable& a, const hkpCollidable& b) const = 0;
+};

lib/hkStubs/Havok/Physics2012/Collide/Filter/hkpCollisionFilter.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <Havok/Common/Base/Memory/Router/hkMemoryRouter.h>
+#include <Havok/Common/Base/Object/hkReferencedObject.h>
+#include <Havok/Common/Base/Types/hkBaseTypes.h>
+#include <Havok/Physics2012/Collide/Filter/hkpCollidableCollidableFilter.h>
+#include <Havok/Physics2012/Collide/Filter/hkpRayCollidableFilter.h>
+#include <Havok/Physics2012/Collide/Filter/hkpShapeCollectionFilter.h>
+#include <Havok/Physics2012/Collide/Shape/Query/hkpRayShapeCollectionFilter.h>
+
+class hkpWorld;
+
+class hkpCollisionFilter : public hkReferencedObject,
+                           public hkpCollidableCollidableFilter,
+                           public hkpShapeCollectionFilter,
+                           public hkpRayShapeCollectionFilter,
+                           public hkpRayCollidableFilter {
+public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkpCollisionFilter)
+
+    enum hkpFilterType {
+        HK_FILTER_UNKNOWN = 0,
+        HK_FILTER_NULL = 1,
+        HK_FILTER_GROUP = 2,
+        HK_FILTER_LIST = 3,
+        HK_FILTER_CUSTOM = 4,
+        HK_FILTER_PAIR = 5,
+        HK_FILTER_CONSTRAINT = 6,
+    };
+
+    hkpCollisionFilter();
+    explicit hkpCollisionFilter(hkFinishLoadedObjectFlag flag) : hkReferencedObject(flag) {}
+
+    virtual void init(hkpWorld* world) {}
+
+    hkBool isCollisionEnabled(const hkpCollidable& a, const hkpCollidable& b) const override = 0;
+
+    hkBool isCollisionEnabled(const hkpCollisionInput& input, const hkpCdBody& a,
+                              const hkpCdBody& b, const hkpShapeContainer& bContainer,
+                              hkpShapeKey bKey) const override = 0;
+
+    hkBool isCollisionEnabled(const hkpCollisionInput& input, const hkpCdBody& collectionBodyA,
+                              const hkpCdBody& collectionBodyB,
+                              const hkpShapeContainer& containerShapeA,
+                              const hkpShapeContainer& containerShapeB, hkpShapeKey keyA,
+                              hkpShapeKey keyB) const override = 0;
+
+    int numShapeKeyHitsLimitBreached(const hkpCollisionInput& input, const hkpCdBody& bodyA,
+                                     const hkpCdBody& bodyB, const hkpBvTreeShape* bvTreeShapeB,
+                                     hkAabb& aabb, hkpShapeKey* shapeKeysInOut,
+                                     int shapeKeysCapacity) const override;
+
+    hkBool isCollisionEnabled(const hkpShapeRayCastInput& aInput,
+                              const hkpShapeContainer& bContainer,
+                              hkpShapeKey bKey) const override = 0;
+
+    hkBool isCollisionEnabled(const hkpWorldRayCastInput& a,
+                              const hkpCollidable& collidableB) const override = 0;
+
+public:
+    hkUint32 m_prepad[2];
+    hkEnum<hkpFilterType, hkUint32> m_type;
+    hkUint32 m_postpad[3];
+};

lib/hkStubs/Havok/Physics2012/Collide/Filter/hkpConvexListFilter.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <Havok/Common/Base/Memory/Router/hkMemoryRouter.h>
+#include <Havok/Common/Base/Object/hkReferencedObject.h>
+
+class hkpCdBody;
+class hkpCollisionInput;
+
+class hkpConvexListFilter : public hkReferencedObject {
+public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkpConvexListFilter)
+
+    enum ConvexListCollisionType {
+        TREAT_CONVEX_LIST_AS_NORMAL,
+        TREAT_CONVEX_LIST_AS_LIST,
+        TREAT_CONVEX_LIST_AS_CONVEX,
+    };
+
+    virtual ConvexListCollisionType
+    getConvexListCollisionType(const hkpCdBody& convexListBody, const hkpCdBody& otherBody,
+                               const hkpCollisionInput& input) const = 0;
+
+public:
+    explicit hkpConvexListFilter(hkFinishLoadedObjectFlag flag) : hkReferencedObject(flag) {}
+
+protected:
+    hkpConvexListFilter() = default;
+};

lib/hkStubs/Havok/Physics2012/Collide/Filter/hkpRayCollidableFilter.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <Havok/Common/Base/Types/hkBaseTypes.h>
+
+class hkpWorldRayCastInput;
+class hkpCollidable;
+
+class hkpRayCollidableFilter {
+public:
+    virtual ~hkpRayCollidableFilter() = default;
+
+    virtual hkBool isCollisionEnabled(const hkpWorldRayCastInput& a,
+                                      const hkpCollidable& collidableB) const = 0;
+};

lib/hkStubs/Havok/Physics2012/Collide/Filter/hkpShapeCollectionFilter.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <Havok/Common/Base/Types/hkBaseTypes.h>
+#include <Havok/Physics2012/Collide/Shape/hkpShapeBase.h>
+
+class hkAabb;
+class hkpBvTreeShape;
+class hkpCdBody;
+class hkpCollisionInput;
+class hkpShapeContainer;
+
+class hkpShapeCollectionFilter {
+public:
+    virtual hkBool isCollisionEnabled(const hkpCollisionInput& input, const hkpCdBody& bodyA,
+                                      const hkpCdBody& collectionBodyB,
+                                      const hkpShapeContainer& containerShapeB,
+                                      hkpShapeKey keyB) const = 0;
+
+    virtual hkBool isCollisionEnabled(const hkpCollisionInput& input,
+                                      const hkpCdBody& collectionBodyA,
+                                      const hkpCdBody& collectionBodyB,
+                                      const hkpShapeContainer& containerShapeA,
+                                      const hkpShapeContainer& containerShapeB, hkpShapeKey keyA,
+                                      hkpShapeKey keyB) const = 0;
+
+    virtual int numShapeKeyHitsLimitBreached(const hkpCollisionInput& input, const hkpCdBody& bodyA,
+                                             const hkpCdBody& bodyB,
+                                             const hkpBvTreeShape* bvTreeShapeB, hkAabb& aabb,
+                                             hkpShapeKey* shapeKeysInOut,
+                                             int shapeKeysCapacity) const = 0;
+
+    virtual ~hkpShapeCollectionFilter() = default;
+};

lib/hkStubs/Havok/Physics2012/Collide/Shape/Convex/Capsule/hkpCapsuleShape.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Havok/Common/Base/hkBase.h>
-#include <Havok/Physics/Collide/Shape/hkpShape.h>
+#include <Havok/Physics2012/Collide/Shape/hkpShape.h>
 
 class hkpCapsuleShape : public hkpShape {
 public:

lib/hkStubs/Havok/Physics2012/Collide/Shape/Convex/hkpConvexShape.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <Havok/Physics2012/Collide/Shape/hkpShape.h>
+
+// TODO
+class hkpConvexShape {};

lib/hkStubs/Havok/Physics2012/Collide/Shape/HeightField/hkpSphereRepShape.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <Havok/Physics2012/Collide/Shape/hkpShape.h>
+
+// TODO
+class hkpSphereRepShape {};

lib/hkStubs/Havok/Physics2012/Collide/Shape/Query/hkpRayShapeCollectionFilter.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <Havok/Common/Base/Types/hkBaseTypes.h>
+#include <Havok/Physics2012/Collide/Shape/hkpShapeBase.h>
+
+class hkpShapeRayCastInput;
+class hkpShapeContainer;
+
+class hkpRayShapeCollectionFilter {
+public:
+    virtual hkBool isCollisionEnabled(const hkpShapeRayCastInput& aInput,
+                                      const hkpShapeContainer& bContainer,
+                                      hkpShapeKey bKey) const = 0;
+
+    virtual ~hkpRayShapeCollectionFilter() = default;
+};

lib/hkStubs/Havok/Physics2012/Collide/Shape/hkpShape.h

@@ -2,6 +2,7 @@
 
 #include <Havok/Common/Base/hkBase.h>
 
+// FIXME: incomplete. Also this should be inheriting from hkpBase
 class hkpShape : public hkReferencedObject {
 public:
     virtual ~hkpShape();

lib/hkStubs/Havok/Physics2012/Collide/Shape/hkpShapeBase.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <Havok/Common/Base/Types/hkBaseTypes.h>
+
+using hkpVertexId = hkUint16;
+using hkpShapeKey = hkUint32;
+
+// FIXME: hkpShapeBase

lib/hkStubs/Havok/Physics2012/Dynamics/Entity/hkpEntity.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Havok/Physics/Dynamics/World/hkpWorldEntity.h>
+#include <Havok/Physics2012/Dynamics/World/hkpWorldEntity.h>
 
 class hkpMotion {
 public:

lib/hkStubs/Havok/Physics2012/Dynamics/Entity/hkpRigidBody.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Havok/Physics/Dynamics/Entity/hkpEntity.h>
+#include <Havok/Physics2012/Dynamics/Entity/hkpEntity.h>
 
 class hkpRigidBody : public hkpEntity {
 public:

lib/hkStubs/Havok/Physics2012/Dynamics/World/Memory/Default/hkpDefaultWorldMemoryWatchDog.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <Havok/Physics2012/Dynamics/World/Memory/hkpWorldMemoryAvailableWatchDog.h>
+
+class hkpDefaultWorldMemoryWatchDog : public hkWorldMemoryAvailableWatchDog {
+public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkpDefaultWorldMemoryWatchDog)
+
+    explicit hkpDefaultWorldMemoryWatchDog(hkInt32 freeHeapMemoryRequested = 20000);
+
+    explicit hkpDefaultWorldMemoryWatchDog(hkFinishLoadedObjectFlag flag)
+        : hkWorldMemoryAvailableWatchDog(flag) {}
+
+    hkInt32 getAmountOfFreeHeapMemoryRequested() override;
+    void freeHeapMemoryTillRequestedAmountIsAvailable(hkpWorld* world) override;
+    void reduceConstraintsInIsland(const MemUsageInfo& info, int numIterations) override;
+
+protected:
+    static void removeObjectsFromIsland(hkpSimulationIsland* island,
+                                        int minAutoRemoveLevelToProcess,
+                                        hkInt32 freeHeapMemoryRequested,
+                                        int& maxFoundAutoRemoveLevelOut);
+
+    hkInt32 m_freeHeapMemoryRequested;
+};

lib/hkStubs/Havok/Physics2012/Dynamics/World/Memory/hkpWorldMemoryAvailableWatchDog.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <Havok/Common/Base/Memory/Router/hkMemoryRouter.h>
+#include <Havok/Common/Base/Object/hkReferencedObject.h>
+
+class hkpSimulationIsland;
+class hkpWorld;
+
+class hkWorldMemoryAvailableWatchDog : public hkReferencedObject {
+public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkWorldMemoryAvailableWatchDog)
+
+    struct MemUsageInfo {
+        HK_DECLARE_CLASS_ALLOCATOR(MemUsageInfo)
+
+        int m_maxRuntimeBlockSize;
+        int m_sumRuntimeBlockSize;
+        hkpSimulationIsland* m_largestSimulationIsland;
+    };
+
+    inline hkWorldMemoryAvailableWatchDog() = default;
+    inline explicit hkWorldMemoryAvailableWatchDog(hkFinishLoadedObjectFlag flag)
+        : hkReferencedObject(flag) {}
+
+    virtual hkInt32 getAmountOfFreeHeapMemoryRequested() = 0;
+    virtual void freeHeapMemoryTillRequestedAmountIsAvailable(hkpWorld* world) = 0;
+    virtual void reduceConstraintsInIsland(const MemUsageInfo& info, int numIterations) = 0;
+};

lib/hkStubs/Havok/Physics2012/Dynamics/World/hkpWorld.cpp

@@ -0,0 +1,3 @@
+#include "Havok/Physics2012/Dynamics/World/hkpWorld.h"
+
+hkpWorld::hkpWorld() {}

lib/hkStubs/Havok/Physics2012/Dynamics/World/hkpWorldCinfo.cpp

@@ -0,0 +1,135 @@
+#include <Havok/Physics2012/Dynamics/World/hkpWorldCinfo.h>
+
+hkpWorldCinfo::hkpWorldCinfo() {
+    m_gravity = {0, -9.8, 0};
+    m_enableSimulationIslands = true;
+    m_broadPhaseQuerySize = 1024;
+    m_mtPostponeAndSortBroadPhaseBorderCallbacks = false;
+    m_broadPhaseWorldAabb = {{-500, -500, -500}, {500, 500, 500}};
+    m_collisionFilter = nullptr;
+    m_convexListFilter = nullptr;
+    m_broadPhaseNumMarkers = 0;
+    m_sizeOfToiEventQueue = 250;
+    m_solverTau = 0.6;
+    m_solverDamp = 1.0;
+    m_contactRestingVelocity = 1.0;
+    m_solverIterations = 4;
+    m_solverMicrosteps = 1;
+    m_maxConstraintViolation = 1.8446726e+19;
+    m_forceCoherentConstraintOrderingInSolver = false;
+    m_snapCollisionToConvexEdgeThreshold = 0.524;
+    m_snapCollisionToConcaveEdgeThreshold = 0.698;
+    m_enableToiWeldRejection = false;
+    m_collisionTolerance = 0.1;
+    m_broadPhaseType = BROADPHASE_TYPE_SAP;
+    m_broadPhaseBorderBehaviour = BROADPHASE_BORDER_ASSERT;
+    m_toiCollisionResponseRotateNormal = 0.2;
+    m_useCompoundSpuElf = false;
+    m_processToisMultithreaded = true;
+    m_maxSectorsPerMidphaseCollideTask = 2;
+    m_maxSectorsPerNarrowphaseCollideTask = 4;
+    m_maxEntriesPerToiMidphaseCollideTask = 4;
+    m_maxEntriesPerToiNarrowphaseCollideTask = 12;
+    m_maxNumToiCollisionPairsSinglethreaded = 0;
+    m_numToisTillAllowedPenetrationSimplifiedToi = 3.0;
+    m_numToisTillAllowedPenetrationToi = 3.0;
+    m_numToisTillAllowedPenetrationToiHigher = 4.0;
+    m_numToisTillAllowedPenetrationToiForced = 20.0;
+    m_deactivationReferenceDistance = 0.02;
+    m_expectedMaxLinearVelocity = 200;
+    m_expectedMinPsiDeltaTime = 1.0f / 30.0f;
+    m_iterativeLinearCastEarlyOutDistance = 0.01;
+    m_enableDeprecatedWelding = false;
+    m_iterativeLinearCastMaxIterations = 20;
+    m_enableDeactivation = true;
+    m_shouldActivateOnRigidBodyTransformChange = true;
+    m_minDesiredIslandSize = 64;
+    m_deactivationNumInactiveFramesSelectFlag0 = 0;
+    m_deactivationNumInactiveFramesSelectFlag1 = 0;
+    m_deactivationIntegrateCounter = 0;
+    m_contactPointGeneration = CONTACT_POINT_REJECT_MANY;
+    m_allowToSkipConfirmedCallbacks = false;
+    m_simulationType = SIMULATION_TYPE_CONTINUOUS;
+    m_frameMarkerPsiSnap = 0.0001;
+    m_memoryWatchDog = nullptr;
+    m_processActionsInSingleThread = true;
+    m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob = false;
+    m_fireCollisionCallbacks = false;
+}
+
+void hkpWorldCinfo::setBroadPhaseWorldSize(hkReal size) {
+    m_broadPhaseWorldAabb.m_min.setAll(-0.5f * size);
+    m_broadPhaseWorldAabb.m_max.setAll(0.5f * size);
+}
+
+void hkpWorldCinfo::setupSolverInfo(hkpWorldCinfo::SolverType st) {
+    switch (st) {
+    case SOLVER_TYPE_2ITERS_SOFT:
+        m_solverTau = 0.3;
+        m_solverDamp = 0.9;
+        m_solverIterations = 2;
+        break;
+    case SOLVER_TYPE_2ITERS_MEDIUM:
+        m_solverTau = 0.6;
+        m_solverDamp = 1.0;
+        m_solverIterations = 2;
+        break;
+    case SOLVER_TYPE_2ITERS_HARD:
+        m_solverTau = 0.9;
+        m_solverDamp = 1.1;
+        m_solverIterations = 2;
+        break;
+
+    case SOLVER_TYPE_4ITERS_SOFT:
+        m_solverTau = 0.3;
+        m_solverDamp = 0.9;
+        m_solverIterations = 4;
+        break;
+    case SOLVER_TYPE_4ITERS_MEDIUM:
+        m_solverTau = 0.6;
+        m_solverDamp = 1.0;
+        m_solverIterations = 4;
+        break;
+    case SOLVER_TYPE_4ITERS_HARD:
+        m_solverTau = 0.9;
+        m_solverDamp = 1.1;
+        m_solverIterations = 4;
+        break;
+
+    case SOLVER_TYPE_8ITERS_SOFT:
+        m_solverTau = 0.3;
+        m_solverDamp = 0.9;
+        m_solverIterations = 8;
+        break;
+    case SOLVER_TYPE_8ITERS_MEDIUM:
+        m_solverTau = 0.6;
+        m_solverDamp = 1.0;
+        m_solverIterations = 8;
+        break;
+    case SOLVER_TYPE_8ITERS_HARD:
+        m_solverTau = 0.9;
+        m_solverDamp = 1.1;
+        m_solverIterations = 8;
+        break;
+
+    case SOLVER_TYPE_INVALID:
+    case SOLVER_TYPE_MAX_ID:
+        break;
+    }
+}
+
+hkpWorldCinfo::hkpWorldCinfo(hkFinishLoadedObjectFlag flag)
+    : hkReferencedObject(flag), m_collisionFilter(flag), m_convexListFilter(flag),
+      m_memoryWatchDog(flag) {
+    if (!flag.m_finishing)
+        return;
+
+    if (m_contactRestingVelocity == 0.0)
+        m_contactRestingVelocity = 1.0;
+
+    if (m_maxEntriesPerToiMidphaseCollideTask == -1)
+        m_maxEntriesPerToiMidphaseCollideTask = 4;
+
+    if (m_maxEntriesPerToiNarrowphaseCollideTask == -1)
+        m_maxEntriesPerToiNarrowphaseCollideTask = 12;
+}

lib/hkStubs/Havok/Physics2012/Dynamics/World/hkpWorldCinfo.h

@@ -0,0 +1,123 @@
+#pragma once
+
+#include <Havok/Common/Base/Math/Vector/hkVector4.h>
+#include <Havok/Common/Base/Memory/Router/hkMemoryRouter.h>
+#include <Havok/Common/Base/Object/hkReferencedObject.h>
+#include <Havok/Common/Base/Types/Geometry/Aabb/hkAabb.h>
+#include <Havok/Common/Base/Types/hkBaseTypes.h>
+#include <Havok/Common/Base/Types/hkRefPtr.h>
+#include <Havok/Physics2012/Collide/Filter/hkpCollisionFilter.h>
+#include <Havok/Physics2012/Collide/Filter/hkpConvexListFilter.h>
+#include <Havok/Physics2012/Dynamics/World/Memory/hkpWorldMemoryAvailableWatchDog.h>
+
+class hkpWorldCinfo : public hkReferencedObject {
+public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkpWorldCinfo)
+
+    enum SolverType {
+        SOLVER_TYPE_INVALID,
+        SOLVER_TYPE_2ITERS_SOFT,
+        SOLVER_TYPE_2ITERS_MEDIUM,
+        SOLVER_TYPE_2ITERS_HARD,
+        SOLVER_TYPE_4ITERS_SOFT,
+        SOLVER_TYPE_4ITERS_MEDIUM,
+        SOLVER_TYPE_4ITERS_HARD,
+        SOLVER_TYPE_8ITERS_SOFT,
+        SOLVER_TYPE_8ITERS_MEDIUM,
+        SOLVER_TYPE_8ITERS_HARD,
+        SOLVER_TYPE_MAX_ID
+    };
+
+    enum SimulationType {
+        SIMULATION_TYPE_INVALID,
+        SIMULATION_TYPE_DISCRETE,
+        SIMULATION_TYPE_CONTINUOUS,
+        SIMULATION_TYPE_MULTITHREADED,
+    };
+
+    enum ContactPointGeneration {
+        CONTACT_POINT_ACCEPT_ALWAYS,
+        CONTACT_POINT_REJECT_DUBIOUS,
+        CONTACT_POINT_REJECT_MANY,
+    };
+
+    enum BroadPhaseType {
+        BROADPHASE_TYPE_SAP,
+        BROADPHASE_TYPE_TREE,
+        BROADPHASE_TYPE_HYBRID,
+    };
+
+    enum BroadPhaseBorderBehaviour {
+        BROADPHASE_BORDER_ASSERT,
+        BROADPHASE_BORDER_FIX_ENTITY,
+        BROADPHASE_BORDER_REMOVE_ENTITY,
+        BROADPHASE_BORDER_DO_NOTHING,
+    };
+
+    hkpWorldCinfo();
+    explicit hkpWorldCinfo(hkFinishLoadedObjectFlag flag);
+    ~hkpWorldCinfo() override = default;
+
+    void setupSolverInfo(SolverType st);
+    void setBroadPhaseWorldSize(hkReal size);
+
+    hkVector4 m_gravity;
+    hkInt32 m_broadPhaseQuerySize;
+    hkReal m_contactRestingVelocity;
+    hkEnum<BroadPhaseType, hkInt8> m_broadPhaseType;
+    hkEnum<BroadPhaseBorderBehaviour, hkInt8> m_broadPhaseBorderBehaviour;
+    hkBool m_mtPostponeAndSortBroadPhaseBorderCallbacks;
+    hkAabb m_broadPhaseWorldAabb;
+    hkReal m_collisionTolerance;
+    hkRefPtr<hkpCollisionFilter> m_collisionFilter;
+    hkRefPtr<hkpConvexListFilter> m_convexListFilter;
+    hkReal m_expectedMaxLinearVelocity;
+    int m_sizeOfToiEventQueue;
+    hkReal m_expectedMinPsiDeltaTime;
+    hkRefPtr<hkWorldMemoryAvailableWatchDog> m_memoryWatchDog;
+
+    hkInt32 m_broadPhaseNumMarkers;
+    hkEnum<ContactPointGeneration, hkInt8> m_contactPointGeneration;
+    hkBool m_allowToSkipConfirmedCallbacks;
+
+    hkReal m_solverTau;
+    hkReal m_solverDamp;
+    hkInt32 m_solverIterations;
+    hkInt32 m_solverMicrosteps;
+    hkReal m_maxConstraintViolation;
+    hkBool m_forceCoherentConstraintOrderingInSolver;
+
+    hkReal m_snapCollisionToConvexEdgeThreshold;
+    hkReal m_snapCollisionToConcaveEdgeThreshold;
+    hkBool m_enableToiWeldRejection;
+    hkBool m_enableDeprecatedWelding;
+    hkReal m_iterativeLinearCastEarlyOutDistance;
+    hkInt32 m_iterativeLinearCastMaxIterations;
+    hkUint8 m_deactivationNumInactiveFramesSelectFlag0;
+    hkUint8 m_deactivationNumInactiveFramesSelectFlag1;
+    hkUint8 m_deactivationIntegrateCounter;
+    hkBool m_shouldActivateOnRigidBodyTransformChange;
+    hkReal m_deactivationReferenceDistance;
+    hkReal m_toiCollisionResponseRotateNormal;
+
+    hkBool m_useCompoundSpuElf;
+    int m_maxSectorsPerMidphaseCollideTask;
+    int m_maxSectorsPerNarrowphaseCollideTask;
+    hkBool m_processToisMultithreaded;
+    int m_maxEntriesPerToiMidphaseCollideTask;
+    int m_maxEntriesPerToiNarrowphaseCollideTask;
+    int m_maxNumToiCollisionPairsSinglethreaded;
+    hkReal m_numToisTillAllowedPenetrationSimplifiedToi;
+    hkReal m_numToisTillAllowedPenetrationToi;
+    hkReal m_numToisTillAllowedPenetrationToiHigher;
+    hkReal m_numToisTillAllowedPenetrationToiForced;
+
+    hkBool m_enableDeactivation;
+    hkEnum<SimulationType, hkInt8> m_simulationType;
+    hkBool m_enableSimulationIslands;
+    hkUint32 m_minDesiredIslandSize;
+    hkBool m_processActionsInSingleThread;
+    hkBool m_allowIntegrationOfIslandsWithoutConstraintsInASeparateJob;
+    hkReal m_frameMarkerPsiSnap;
+    hkBool m_fireCollisionCallbacks;
+};

lib/hkStubs/Havok/Physics2012/Dynamics/World/hkpWorldEntity.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Havok/Physics/Collide/Shape/hkpShape.h>
+#include <Havok/Physics2012/Collide/Shape/hkpShape.h>
 
 class hkpWorldEntity : public hkReferencedObject {
 public:

src/KingSystem/Physics/RigidBody/Shape/physCapsuleShape.cpp

@@ -1,5 +1,5 @@
 #include "KingSystem/Physics/RigidBody/Shape/physCapsuleShape.h"
-#include <Havok/Physics/Collide/Shape/Convex/Capsule/hkpCapsuleShape.h>
+#include <Havok/Physics2012/Collide/Shape/Convex/Capsule/hkpCapsuleShape.h>
 #include <heap/seadHeap.h>
 #include <math/seadMathCalcCommon.h>
 

src/KingSystem/Physics/RigidBody/Shape/physCapsuleShape.h

@@ -1,12 +1,12 @@
 #pragma once
 
+#include <Havok/Common/Base/Math/Vector/hkVector4.h>
 #include <math/seadVector.h>
 #include <prim/seadTypedBitFlag.h>
 #include <thread/seadAtomic.h>
 #include "KingSystem/Physics/RigidBody/physRigidBody.h"
 
 class hkpShape;
-class hkVector4;
 
 namespace ksys::phys {
 

src/KingSystem/Physics/RigidBody/physRigidBody.cpp

@@ -1,5 +1,5 @@
 #include "KingSystem/Physics/RigidBody/physRigidBody.h"
-#include <Havok/Physics/Dynamics/Entity/hkpRigidBody.h>
+#include <Havok/Physics2012/Dynamics/Entity/hkpRigidBody.h>
 #include "KingSystem/Physics/System/physMemSystem.h"
 
 namespace ksys::phys {