Merge pull request #267 from FreeZoneMods/xd_dev

CAI_Space improvement

src/Common/Common.vcxproj

@@ -180,6 +180,7 @@
     <ClInclude Include="..\xrCommon\xr_list.h" />
     <ClInclude Include="..\xrCommon\xr_map.h" />
     <ClInclude Include="..\xrCommon\xr_set.h" />
+    <ClInclude Include="..\xrCommon\xr_smart_pointers.h" />
     <ClInclude Include="..\xrCommon\xr_stack.h" />
     <ClInclude Include="..\xrCommon\xr_string.h" />
     <ClInclude Include="..\xrCommon\xr_unordered_map.h" />

src/Common/Common.vcxproj.filters

@@ -85,6 +85,9 @@
     <ClInclude Include="..\xrCommon\xr_array.h">
       <Filter>xrCommon</Filter>
     </ClInclude>
+    <ClInclude Include="..\xrCommon\xr_smart_pointers.h">
+      <Filter>xrCommon</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="NvMender2003">

src/editors/ECore/stdafx.h

@@ -108,6 +108,7 @@ typedef TMsgDlgBtn TMsgDlgButtons[mbHelp];
 #include "xrCore/xr_token.h"
 #include "xrCommon/xr_vector.h"
 #include "xrCommon/xr_string.h"
+#include "xrCommon/xr_smart_pointers.h"
 #include "xrCore/Animation/Bone.hpp"
 #include "xrCore/Animation/Motion.hpp"
 

src/utils/xrSE_Factory/ai_space.cpp

@@ -11,9 +11,17 @@
 #include "xrScriptEngine/script_engine.hpp"
 #include "xrServerEntities/object_factory.h"
 
-CAI_Space* g_ai_space = nullptr;
+static CAI_Space g_ai_space;
 
-CAI_Space::CAI_Space() { m_script_engine = nullptr; }
+CAI_Space& CAI_Space::GetInstance()
+{
+    auto& instance = g_ai_space;
+    if (!instance.m_inited)
+    {
+        instance.init();
+    }
+    return instance;
+}
 
 void CAI_Space::RegisterScriptClasses()
 {
@@ -49,13 +57,16 @@ void CAI_Space::RegisterScriptClasses()
 
 void CAI_Space::init()
 {
-    VERIFY(!m_script_engine);
+    R_ASSERT(!m_inited);
+
     VERIFY(!GEnv.ScriptEngine);
-    GEnv.ScriptEngine = m_script_engine = new CScriptEngine(true);
+    GEnv.ScriptEngine = new CScriptEngine(true);
     XRay::ScriptExporter::Reset(); // mark all nodes as undone
-    m_script_engine->init(XRay::ScriptExporter::Export, true);
+    GEnv.ScriptEngine->init(XRay::ScriptExporter::Export, true);
     RegisterScriptClasses();
     object_factory().register_script();
+
+    m_inited = true;
 }
 
-CAI_Space::~CAI_Space() { xr_delete(m_script_engine); }
+CAI_Space::~CAI_Space() { xr_delete(GEnv.ScriptEngine); }

src/utils/xrSE_Factory/ai_space.h

@@ -7,24 +7,36 @@
 ////////////////////////////////////////////////////////////////////////////
 
 #pragma once
+#include "xrCore/Events/Notifier.h"
 
 class CScriptEngine;
 
 class CAI_Space
 {
 private:
-    CScriptEngine* m_script_engine;
+    bool m_inited = false;
 
+    void init();
     void RegisterScriptClasses();
 
 public:
-    CAI_Space();
+    CAI_Space() = default;
+    CAI_Space(const CAI_Space&) = delete;
+    CAI_Space& operator=(const CAI_Space&) = delete;
     virtual ~CAI_Space();
-    void init();
+    static CAI_Space& GetInstance();
+
     IC CScriptEngine& script_engine() const;
-};
 
-extern CAI_Space* g_ai_space;
+    enum EEventID
+    {
+        EVENT_SCRIPT_ENGINE_STARTED,
+        EVENT_SCRIPT_ENGINE_RESET,
+        EVENT_COUNT,
+    };
+    CEventNotifierCallback::CID Subscribe(CEventNotifierCallback* cb, EEventID event_id) { return 0; }
+    bool Unsubscribe(CEventNotifierCallback::CID cid, EEventID event_id) { return true; }
+};
 
 IC CAI_Space& ai();
 

src/utils/xrSE_Factory/ai_space_inline.h

@@ -10,16 +10,8 @@
 
 IC CScriptEngine& CAI_Space::script_engine() const
 {
-    VERIFY(m_script_engine);
-    return *m_script_engine;
+    VERIFY(GEnv.ScriptEngine);
+    return *GEnv.ScriptEngine;
 }
 
-IC CAI_Space& ai()
-{
-    if (!g_ai_space)
-    {
-        g_ai_space = new CAI_Space();
-        g_ai_space->init();
-    }
-    return *g_ai_space;
-}
+IC CAI_Space& ai() { return CAI_Space::GetInstance(); }

src/utils/xrSE_Factory/xrSE_Factory.cpp

@@ -60,7 +60,6 @@ BOOL APIENTRY DllMain(HANDLE module_handle, DWORD call_reason, LPVOID reserved)
         auto s = (CInifile**)&pSettings;
         xr_delete(*s);
         xr_delete(g_property_list_helper);
-        xr_delete(g_ai_space);
         xr_delete(g_object_factory);
         if (prop_helper_module)
             prop_helper_module = nullptr;

src/xrCommon/xr_smart_pointers.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <memory>
+
+template <typename T>
+using xr_unique_ptr = std::unique_ptr<T>;
+
+template <typename T>
+using xr_shared_ptr = std::shared_ptr<T>;
+
+template <class T, class... Args>
+inline xr_unique_ptr<T> xr_make_unique(Args&&... args)
+{
+    return std::make_unique<T>(args...);
+}
+
+template <class T, class... Args>
+inline xr_shared_ptr<T> xr_make_shared(Args&&... args)
+{
+    return std::make_shared<T>(args...);
+}

src/xrCore/Events/Notifier.h

@@ -0,0 +1,114 @@
+#pragma once
+
+#include "xrCommon/xr_smart_pointers.h"
+#include "xrCommon/xr_vector.h"
+#include "xrCommon/xr_array.h"
+#include "xrCore/Threading/Lock.hpp"
+#include "xrCore/Threading/ScopeLock.hpp"
+
+class CEventNotifierCallback
+{
+public:
+    using CID = size_t;
+    static const CID INVALID_CID = std::numeric_limits<CID>::max();
+
+    virtual void ProcessEvent() = 0;
+    virtual ~CEventNotifierCallback(){};
+};
+
+template <unsigned int CNT>
+class CEventNotifier
+{
+private:
+    class CCallbackStorage
+    {
+        class CCallbackWrapper
+        {
+        public:
+            xr_unique_ptr<CEventNotifierCallback> callback;
+            bool destroying = false;
+            bool executing = false;
+
+            CCallbackWrapper(CEventNotifierCallback* cb) : callback(cb){};
+            bool operator==(const CEventNotifierCallback* cb) { return cb == callback.get(); }
+            void Reset()
+            {
+                callback.reset(nullptr);
+                destroying = false;
+                executing = false;
+            }
+        };
+        xr_vector<CCallbackWrapper> m_callbacks;
+        Lock m_lock;
+
+    public:
+        CEventNotifierCallback::CID RegisterCallback(CEventNotifierCallback* cb)
+        {
+            ScopeLock lock(&m_lock);
+            auto it = std::find(m_callbacks.begin(), m_callbacks.end(), nullptr);
+            return (it == m_callbacks.end()) ? (m_callbacks.emplace_back(cb), m_callbacks.size() - 1) :
+                                               (it->callback.reset(cb), std::distance(m_callbacks.begin(), it));
+        }
+
+        bool UnregisterCallback(CEventNotifierCallback::CID cid)
+        {
+            bool result = false;
+            ScopeLock lock(&m_lock);
+            if (cid < m_callbacks.size() && m_callbacks[cid].callback != nullptr)
+            {
+                if (!m_callbacks[cid].destroying)
+                {
+                    result = true;
+                    m_callbacks[cid].destroying = true;
+                }
+
+                if (!m_callbacks[cid].executing)
+                {
+                    m_callbacks[cid].Reset();
+                }
+            }
+            return result;
+        }
+
+        void ExecuteCallbacks()
+        {
+            ScopeLock lock(&m_lock);
+            for (CEventNotifierCallback::CID i = 0; i < m_callbacks.size(); ++i)
+            {
+                auto& cb = m_callbacks[i];
+                if (cb.callback != nullptr && !cb.destroying)
+                {
+                    cb.executing = true;
+                    cb.callback->ProcessEvent();
+                    cb.executing = false;
+
+                    if (cb.destroying)
+                    {
+                        UnregisterCallback(i);
+                    }
+                }
+            }
+        }
+    };
+
+    xr_array<CCallbackStorage, CNT> m_callbacks;
+
+public:
+    CEventNotifierCallback::CID RegisterCallback(CEventNotifierCallback* cb, unsigned int event_id)
+    {
+        R_ASSERT(event_id < CNT);
+        return m_callbacks[event_id].RegisterCallback(cb);
+    }
+
+    bool UnregisterCallback(CEventNotifierCallback::CID cid, unsigned int event_id)
+    {
+        R_ASSERT(event_id < CNT);
+        return m_callbacks[event_id].UnregisterCallback(cid);
+    }
+
+    void FireEvent(unsigned int event_id)
+    {
+        R_ASSERT(event_id < CNT);
+        m_callbacks[event_id].ExecuteCallbacks();
+    }
+};

src/xrCore/FileSystem.cpp

@@ -11,7 +11,7 @@
 #include "vfw.h"
 #endif
 
-std::unique_ptr<EFS_Utils> xr_EFS;
+xr_unique_ptr<EFS_Utils> xr_EFS;
 //----------------------------------------------------
 EFS_Utils::EFS_Utils() {}
 EFS_Utils::~EFS_Utils() {}

src/xrCore/FileSystem.h

@@ -42,7 +42,7 @@ class XRCORE_API EFS_Utils
     static xr_string ExtractFileExt(LPCSTR src);
     static xr_string ExcludeBasePath(LPCSTR full_path, LPCSTR excl_path);
 };
-extern XRCORE_API std::unique_ptr<EFS_Utils> xr_EFS;
+extern XRCORE_API xr_unique_ptr<EFS_Utils> xr_EFS;
 #define EFS (*xr_EFS)
 
 #endif /*_INCDEF_FileSystem_H_*/

src/xrCore/LocatorAPI.cpp

@@ -26,7 +26,7 @@
 
 const u32 BIG_FILE_READER_WINDOW_SIZE = 1024 * 1024;
 
-std::unique_ptr<CLocatorAPI> xr_FS;
+xr_unique_ptr<CLocatorAPI> xr_FS;
 
 #ifdef _EDITOR
 static constexpr pcstr FSLTX = "fs.ltx"

src/xrCore/LocatorAPI.h

@@ -10,6 +10,7 @@
 #include "LocatorAPI_defs.h"
 //#include "xrCore/Threading/Lock.hpp"
 #include "xrCommon/xr_map.h"
+#include "xrCommon/xr_smart_pointers.h"
 #include "xrCommon/predicates.h"
 #include "Common/Noncopyable.hpp"
 
@@ -255,5 +256,5 @@ class XRCORE_API CLocatorAPI : Noncopyable
     void unlock_rescan();
 };
 
-extern XRCORE_API std::unique_ptr<CLocatorAPI> xr_FS;
+extern XRCORE_API xr_unique_ptr<CLocatorAPI> xr_FS;
 #define FS (*xr_FS)

src/xrCore/ModuleLookup.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include <memory>
+#include "xrCommon/xr_smart_pointers.h"
 
 namespace XRay
 {
@@ -23,15 +23,15 @@ class XRCORE_API ModuleHandle
     void* GetProcAddress(pcstr procName) const;
 };
 
-using Module = std::unique_ptr<ModuleHandle>;
+using Module = xr_unique_ptr<ModuleHandle>;
 
 inline auto LoadModule(bool dontUnload = false)
 {
-    return std::make_unique<ModuleHandle>(dontUnload);
+    return xr_make_unique<ModuleHandle>(dontUnload);
 }
 
 inline auto LoadModule(pcstr moduleName, bool dontUnload = false)
 {
-    return std::make_unique<ModuleHandle>(moduleName, dontUnload);
+    return xr_make_unique<ModuleHandle>(moduleName, dontUnload);
 }
 }

src/xrCore/Threading/ThreadPool.hpp

@@ -15,7 +15,7 @@
 #include <mutex>
 #include <condition_variable>
 #include <functional>
-#include <memory>
+#include "xrCommon/xr_smart_pointers.h"
 
 class XRCORE_API Thread
 {
@@ -42,7 +42,7 @@ class XRCORE_API Thread
 class ThreadPool
 {
 public:
-    xr_vector<std::unique_ptr<Thread>> threads;
+    xr_vector<xr_unique_ptr<Thread>> threads;
 
     void initialize()
     {

src/xrCore/cpuid.cpp

@@ -175,7 +175,7 @@ unsigned int query_processor_info(processor_info* pinfo)
     DWORD byteOffset = 0;
     GetLogicalProcessorInformation(nullptr, &returnedLength);
 
-    auto buffer = std::make_unique<u8[]>(returnedLength);
+    auto buffer = xr_make_unique<u8[]>(returnedLength);
     auto ptr = reinterpret_cast<PSYSTEM_LOGICAL_PROCESSOR_INFORMATION>(buffer.get());
     GetLogicalProcessorInformation(ptr, &returnedLength);
 

src/xrCore/xrCore.cpp

@@ -253,9 +253,9 @@ void xrCore::Initialize(pcstr _ApplicationName, pcstr commandLine, LogCallback c
 
         rtc_initialize();
 
-        xr_FS = std::make_unique<CLocatorAPI>();
+        xr_FS = xr_make_unique<CLocatorAPI>();
 
-        xr_EFS = std::make_unique<EFS_Utils>();
+        xr_EFS = xr_make_unique<EFS_Utils>();
         //. R_ASSERT (co_res==S_OK);
     }
     if (init_fs)

src/xrCore/xrCore.vcxproj

@@ -364,6 +364,7 @@ call .GitInfo.cmd</Command>
     </ClInclude>
     <ClInclude Include="Debug\MiniDump.h" />
     <ClInclude Include="dump_string.h" />
+    <ClInclude Include="Events\Notifier.h" />
     <ClInclude Include="fastdelegate.h" />
     <CustomBuild Include="FileSystem.h" />
     <ClInclude Include="FileCRC32.h" />