Havok: Add hkRootLevelContainer

lib/hkStubs/CMakeLists.txt

@@ -33,8 +33,11 @@ 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/hkRefVariant.h
   Havok/Common/Base/Types/Geometry/Aabb/hkAabb.h
 
+  Havok/Common/Serialize/Util/hkRootLevelContainer.h
+
   Havok/Geometry/Collide/Shapes/hkcdShape.h
 
   Havok/Physics2012/Collide/Agent/hkpCollisionInput.h

lib/hkStubs/Havok/Common/Base/Container/String/hkStringPtr.h

@@ -1,11 +1,30 @@
 #pragma once
 
+#include <Havok/Common/Base/Memory/Router/hkMemoryRouter.h>
+
 class hkStringPtr {
 public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkStringPtr)
+
+    enum StringFlags {
+        OWNED_FLAG = 0x1,
+    };
+
     hkStringPtr();
 
+    inline const char* cString() const;
+    inline operator const char*() const;
+
     hkStringPtr& operator=(const char* s);
 
 private:
     const char* m_stringAndFlag;
 };
+
+inline const char* hkStringPtr::cString() const {
+    return reinterpret_cast<const char*>(uintptr_t(m_stringAndFlag) & ~OWNED_FLAG);
+}
+
+inline hkStringPtr::operator const char*() const {
+    return cString();
+}

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

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <Havok/Common/Base/Memory/Router/hkMemoryRouter.h>
+#include <Havok/Common/Base/Types/hkBaseDefs.h>
+#include <Havok/Common/Base/Types/hkBaseTypes.h>
+#include <Havok/Common/Base/Types/hkRefPtr.h>
+
+class hkRefVariant : public hkRefPtr<hkReferencedObject> {
+public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkRefVariant)
+
+    HK_FORCE_INLINE hkRefVariant() = default;
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    HK_FORCE_INLINE hkRefVariant(const hkReferencedObject* o);
+    HK_FORCE_INLINE hkRefVariant(const hkRefVariant& other);
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    hkRefVariant(const hkVariant& v);
+    hkRefVariant(void* o, const hkClass* k);
+    HK_FORCE_INLINE explicit hkRefVariant(hkFinishLoadedObjectFlag f);
+
+    HK_FORCE_INLINE hkRefVariant& operator=(const hkRefVariant& other);
+    HK_FORCE_INLINE hkRefVariant& operator=(const hkReferencedObject* o);
+
+    void set(void* o, const hkClass* k);
+
+    HK_FORCE_INLINE operator hkVariant() const;  // NOLINT(google-explicit-constructor)
+    const hkClass* getClass() const;
+};
+
+inline hkRefVariant::hkRefVariant(const hkReferencedObject* o)
+    : hkRefPtr(const_cast<hkReferencedObject*>(o)) {}
+
+inline hkRefVariant::hkRefVariant(const hkRefVariant& other) = default;
+
+inline hkRefVariant::hkRefVariant(hkFinishLoadedObjectFlag f) : hkRefPtr(f) {}
+
+inline hkRefVariant& hkRefVariant::operator=(const hkRefVariant& other) {
+    if (this != &other)
+        hkRefPtr::operator=(other);
+    return *this;
+}
+
+inline hkRefVariant& hkRefVariant::operator=(const hkReferencedObject* o) {
+    if (val() != o)
+        hkRefPtr::operator=(const_cast<hkReferencedObject*>(o));
+    return *this;
+}
+
+inline hkRefVariant::operator hkVariant() const {
+    hkVariant v;
+    v.m_object = const_cast<hkReferencedObject*>(val());
+    v.m_class = getClass();
+    return v;
+}

lib/hkStubs/Havok/Common/Base/hkBase.h

@@ -4,6 +4,8 @@
 #include <Havok/Common/Base/Object/hkReferencedObject.h>
 #include <Havok/Common/Base/Types/hkBaseDefs.h>
 #include <Havok/Common/Base/Types/hkBaseTypes.h>
+#include <Havok/Common/Base/Types/hkRefPtr.h>
+#include <Havok/Common/Base/Types/hkRefVariant.h>
 
 #include <Havok/Common/Base/Math/hkMath.h>
 

lib/hkStubs/Havok/Common/Serialize/Util/hkRootLevelContainer.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <Havok/Common/Base/Reflection/hkClass.h>
+#include <Havok/Common/Base/hkBase.h>
+
+class hkRootLevelContainer {
+public:
+    HK_DECLARE_CLASS_ALLOCATOR(hkRootLevelContainer)
+    HK_DECLARE_REFLECTION()
+
+public:
+    HK_FORCE_INLINE hkRootLevelContainer();
+    HK_FORCE_INLINE hkRootLevelContainer(const hkRootLevelContainer& other);
+    explicit hkRootLevelContainer(hkFinishLoadedObjectFlag f);
+
+    HK_FORCE_INLINE ~hkRootLevelContainer();
+
+    hkRootLevelContainer& operator=(const hkRootLevelContainer&) = default;
+
+    class NamedVariant {
+    public:
+        HK_DECLARE_CLASS_ALLOCATOR(hkRootLevelContainer::NamedVariant)
+        HK_DECLARE_REFLECTION()
+
+        HK_FORCE_INLINE NamedVariant();
+        explicit NamedVariant(hkFinishLoadedObjectFlag flag);
+
+        NamedVariant(const char* name, void* object, const hkClass* klass);
+        NamedVariant(const char* name, const hkVariant& v);
+
+        HK_FORCE_INLINE void set(const char* name, void* object, const hkClass* klass);
+        HK_FORCE_INLINE void set(const char* name, const hkVariant& v);
+
+        HK_FORCE_INLINE const char* getTypeName() const;
+        HK_FORCE_INLINE const char* getName() const;
+        HK_FORCE_INLINE void* getObject() const;
+        HK_FORCE_INLINE const hkClass* getClass() const;
+        HK_FORCE_INLINE const hkRefVariant& getRefVariant() const;
+
+    private:
+        hkStringPtr m_name;
+        hkStringPtr m_className;
+        hkRefVariant m_variant;
+    };
+
+    template <typename T>
+    inline T* findObject(const void* prevObject = nullptr) const;
+
+    void* findObjectByType(const char* typeName, const void* prevObject = nullptr) const;
+    void* findObjectByName(const char* objectName, const void* prevObject = nullptr) const;
+
+    hkArray<NamedVariant> m_namedVariants;
+};
+
+inline hkRootLevelContainer::hkRootLevelContainer() = default;
+
+inline hkRootLevelContainer::hkRootLevelContainer(const hkRootLevelContainer& other) {
+    *this = other;
+}
+
+inline hkRootLevelContainer::~hkRootLevelContainer() = default;
+
+template <typename T>
+inline T* hkRootLevelContainer::findObject(const void* prevObject) const {
+    if (void* p = findObjectByType(T::staticClass().getName(), prevObject))
+        return static_cast<T*>(p);
+    return nullptr;
+}
+
+inline hkRootLevelContainer::NamedVariant::NamedVariant() = default;
+
+inline void hkRootLevelContainer::NamedVariant::set(const char* name, void* object,
+                                                    const hkClass* klass) {
+    m_name = name;
+    m_variant.set(object, klass);
+    m_className = m_variant.getClass() ? m_variant.getClass()->getName() : nullptr;
+}
+
+inline void hkRootLevelContainer::NamedVariant::set(const char* name, const hkVariant& v) {
+    m_name = name;
+    m_variant = v;
+    m_className = m_variant.getClass() ? m_variant.getClass()->getName() : nullptr;
+}
+
+inline const char* hkRootLevelContainer::NamedVariant::getTypeName() const {
+    return m_variant.getClass() ? m_variant.getClass()->getName() :
+                                  static_cast<const char*>(m_className);
+}
+
+inline const char* hkRootLevelContainer::NamedVariant::getName() const {
+    return m_name;
+}
+
+inline void* hkRootLevelContainer::NamedVariant::getObject() const {
+    return m_variant.val();
+}
+
+inline const hkClass* hkRootLevelContainer::NamedVariant::getClass() const {
+    return m_variant.getClass();
+}
+
+inline const hkRefVariant& hkRootLevelContainer::NamedVariant::getRefVariant() const {
+    return m_variant;
+}