Working on stability + luajit debugging

yohjimane · yohjimane · commit e461644f75ae · 2025-10-06T22:52:58.000-07:00
diff --git a/Externals/LuaJIT-proj/LuaJIT.vcxproj b/Externals/LuaJIT-proj/LuaJIT.vcxproj
@@ -29,7 +29,7 @@
     <ClCompile>
       <AdditionalIncludeDirectories>$(ProjectDir)intermediate\$(PlatformShortName);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>LUA_BUILD_AS_DLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <PreprocessorDefinitions Condition="'$(Platform)'=='x64'">LUAJIT_ENABLE_GC64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions Condition="'$(Platform)'=='x64'">LUAJIT_ENABLE_GC64;LUA_USE_ASSERT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <PrecompiledHeader>NotUsing</PrecompiledHeader>
       <TreatWarningAsError>false</TreatWarningAsError>
     </ClCompile>
diff --git a/src/xrAnimation/OzzKinematics.cpp b/src/xrAnimation/OzzKinematics.cpp
@@ -870,7 +870,15 @@ bool OzzKinematics::LoadOzzAnimationsFromFile(const xr_string& relative_path)
 
         payload.resize(static_cast<size_t>(length));
         if (!payload.empty())
-            file.Read(payload.data(), payload.size());
+        {
+            const size_t bytes_read = file.Read(payload.data(), payload.size());
+            if (bytes_read != payload.size())
+            {
+                Msg("[ozz] failed to read %zu bytes from '%s' (got %zu)", payload.size(), absolute.string().c_str(),
+                    bytes_read);
+                return false;
+            }
+        }
     }
     else
     {
@@ -882,7 +890,15 @@ bool OzzKinematics::LoadOzzAnimationsFromFile(const xr_string& relative_path)
         const size_t length = static_cast<size_t>(reader->length());
         payload.resize(length);
         if (length > 0)
+        {
+            if (!reader->pointer())
+            {
+                Msg("[ozz] reader for '%s' returned null pointer", relative_path.c_str());
+                FS.r_close(reader);
+                return false;
+            }
             std::memcpy(payload.data(), reader->pointer(), length);
+        }
         FS.r_close(reader);
     }
 
@@ -1964,9 +1980,64 @@ void OzzKinematics::LL_BuldBoneMatrixDequatize(const CBoneData* bd, u8 channel_m
     }
 }
 
-void OzzKinematics::LL_BoneMatrixBuild(CBoneInstance& /*bi*/, const Fmatrix* /*parent*/, const SKeyTable& /*keys*/)
+void OzzKinematics::LL_BoneMatrixBuild(CBoneInstance& bi, const Fmatrix* parent, const SKeyTable& keys)
 {
-    NotImplemented(__FUNCTION__);
+    CKey channel_keys[MAX_CHANNELS];
+    Render::animation::channel_def channel_defs[MAX_CHANNELS];
+    u16 channel_count = 0;
+
+    for (u16 channel = 0; channel < MAX_CHANNELS; ++channel)
+    {
+        if (channel != 0 && keys.chanel_blend_conts[channel] == 0)
+            continue;
+
+        Render::animation::channel_def def{};
+        def.rule = channelRules[channel];
+        def.factor = channelFactors[channel];
+
+        channel_defs[channel_count] = def;
+        xray::render::RENDER_NAMESPACE::process_single_channel(channel_keys[channel_count], def, keys.keys[channel], keys.blends[channel],
+            keys.chanel_blend_conts[channel]);
+        ++channel_count;
+    }
+
+    if (channel_count == 0)
+    {
+        if (parent)
+            bi.mTransform = *parent;
+        else
+            bi.mTransform.identity();
+        return;
+    }
+
+    CKey mixed_key;
+    xray::render::RENDER_NAMESPACE::MixChannels(mixed_key, channel_keys, channel_defs, channel_count);
+
+    Fmatrix local_matrix;
+    local_matrix.mk_xform(mixed_key.Q, mixed_key.T);
+
+    if (parent)
+        bi.mTransform.mul_43(*parent, local_matrix);
+    else
+        bi.mTransform = local_matrix;
+
+#ifdef DEBUG
+#ifndef _EDITOR
+    if (!xray::render::RENDER_NAMESPACE::check_scale(local_matrix))
+    {
+        VERIFY(xray::render::RENDER_NAMESPACE::check_scale(bi.mTransform));
+    }
+    VERIFY(_valid(bi.mTransform));
+
+    Fbox dbg_box;
+    constexpr float kBoxExtent = 100000.f;
+    dbg_box.set(-kBoxExtent, -kBoxExtent, -kBoxExtent, kBoxExtent, kBoxExtent, kBoxExtent);
+    VERIFY2(dbg_box.contains(bi.mTransform.c),
+        make_string("[OzzKinematics] bone transform out of bounds: (%.3f, %.3f, %.3f)", bi.mTransform.c.x,
+            bi.mTransform.c.y, bi.mTransform.c.z)
+            .c_str());
+#endif
+#endif
 }
 
 IBlendDestroyCallback* OzzKinematics::GetBlendDestroyCallback()
diff --git a/src/xrScriptEngine/script_engine.cpp b/src/xrScriptEngine/script_engine.cpp
@@ -30,6 +30,7 @@
 #include <luabind/class_info.hpp>
 
 #include <stdarg.h>
+#include <limits>
 
 Flags32 g_LuaDebug;
 int g_LuaDumpDepth = 0;
@@ -140,8 +141,11 @@ void CScriptEngine::reinit()
         file_header = file_header_new;
     else
         file_header = file_header_old;
-    scriptBufferSize = 1024 * 1024;
+    constexpr size_t kInitialScriptBufferSize = 1024 * 1024 + 1;
+    scriptBufferSize = kInitialScriptBufferSize;
     scriptBuffer = xr_alloc<char>(scriptBufferSize);
+    if (scriptBuffer)
+        scriptBuffer[0] = '\0';
 
     if (m_profiler)
         m_profiler->OnReinit(m_virtual_machine);
@@ -313,6 +317,9 @@ bool CScriptEngine::parse_namespace(pcstr caNamespaceName, pstr b, size_t b_size
 bool CScriptEngine::load_buffer(
 lua_State* L, LPCSTR caBuffer, size_t tSize, LPCSTR caScriptName, LPCSTR caNameSpaceName)
 {
+    m_lastLoadedChunk = caScriptName ? caScriptName : "<unnamed chunk>";
+    m_lastLoadedNamespace = caNameSpaceName ? caNameSpaceName : GlobalNamespace;
+
     int l_iErrorCode;
     if (caNameSpaceName && xr_strcmp(GlobalNamespace, caNameSpaceName))
     {
@@ -323,14 +330,35 @@ lua_State* L, LPCSTR caBuffer, size_t tSize, LPCSTR caScriptName, LPCSTR caNameS
         xr_sprintf(insert, header, caNameSpaceName, a, b);
         const size_t str_len = xr_strlen(insert);
         const size_t total_size = str_len + tSize;
-        if (total_size >= scriptBufferSize)
+        if (total_size < str_len)
+        {
+            script_log(LuaMessageType::Error, "script namespace header overflow for %s", caScriptName);
+            on_error(L);
+            return false;
+        }
+        if (total_size > std::numeric_limits<size_t>::max() - 1)
+        {
+            script_log(LuaMessageType::Error, "script buffer size overflow for %s", caScriptName);
+            on_error(L);
+            return false;
+        }
+        const size_t required_size = total_size + 1; // extra byte for sentinel '\0'
+        if (required_size > scriptBufferSize)
         {
-            scriptBufferSize = total_size;
-            scriptBuffer = (char*)xr_realloc(scriptBuffer, scriptBufferSize);
+            scriptBufferSize = required_size;
+            scriptBuffer = static_cast<char*>(xr_realloc(scriptBuffer, scriptBufferSize));
+            if (!scriptBuffer)
+            {
+                script_log(LuaMessageType::Error, "out of memory while resizing script buffer for %s", caScriptName);
+                on_error(L);
+                return false;
+            }
         }
-        xr_strcpy(scriptBuffer, total_size, insert);
-        CopyMemory(scriptBuffer + str_len, caBuffer, tSize);
-        l_iErrorCode = luaL_loadbuffer(L, scriptBuffer, tSize + str_len, caScriptName);
+        xr_strcpy(scriptBuffer, scriptBufferSize, insert);
+        if (tSize > 0)
+            CopyMemory(scriptBuffer + str_len, caBuffer, tSize);
+        scriptBuffer[total_size] = '\0';
+        l_iErrorCode = luaL_loadbuffer(L, scriptBuffer, total_size, caScriptName);
     }
     else
         l_iErrorCode = luaL_loadbuffer(L, caBuffer, tSize, caScriptName);
@@ -370,6 +398,7 @@ bool CScriptEngine::do_file(LPCSTR caScriptName, LPCSTR caNameSpaceName)
     if (debugger())
         errFuncId = debugger()->PrepareLua(lua());
 #endif
+    m_lastExecutingChunk = caScriptName ? caScriptName : "<unnamed chunk>";
     if (0) //.
     {
         for (int i = 0; lua_type(lua(), -i - 1); i++)
@@ -639,6 +668,9 @@ CScriptEngine::CScriptEngine(bool is_editor, bool is_with_profiler)
     m_reload_modules = false;
     m_last_no_file_length = 0;
     *m_last_no_file = 0;
+    m_lastLoadedChunk.clear();
+    m_lastLoadedNamespace = GlobalNamespace;
+    m_lastExecutingChunk.clear();
 #ifdef USE_DEBUGGER
 #ifndef USE_LUA_STUDIO
     static_assert(false, "Do not define USE_LUA_STUDIO macro without USE_DEBUGGER macro");
@@ -1174,3 +1206,37 @@ bool CScriptEngine::is_editor()
 {
     return m_is_editor;
 }
+
+void CScriptEngine::OnLuaAssertion(lua_State* state, pcstr file, int line, pcstr func, pcstr message)
+{
+    const pcstr loadedChunk = m_lastLoadedChunk.empty() ? "<none>" : m_lastLoadedChunk.c_str();
+    const pcstr namespaceName = m_lastLoadedNamespace.empty() ? GlobalNamespace : m_lastLoadedNamespace.c_str();
+    const pcstr executingChunk = m_lastExecutingChunk.empty() ? loadedChunk : m_lastExecutingChunk.c_str();
+
+    Msg("! [LuaJIT] ASSERT %s:%d (%s): %s", file ? file : "<unknown>", line,
+        func ? func : "<unknown>", (message && message[0]) ? message : "<no message>");
+    Msg("! [LuaJIT] last loaded chunk: %s (namespace: %s)", loadedChunk, namespaceName);
+    Msg("! [LuaJIT] last executing chunk: %s", executingChunk);
+
+#ifdef DEBUG
+    const bool reenter = logReenterability;
+    logReenterability = true;
+    if (state)
+        print_stack(state);
+    logReenterability = reenter;
+#else
+    (void)state;
+#endif
+}
+
+extern "C" XRSCRIPTENGINE_API void xr_LuaAssertionHandler(lua_State* state, const char* file, int line, const char* func, const char* message)
+{
+    if (!state)
+        return;
+
+    CScriptEngine* engine = CScriptEngine::GetInstance(state);
+    if (!engine)
+        return;
+
+    engine->OnLuaAssertion(state, file, line, func, message);
+}
diff --git a/src/xrScriptEngine/script_engine.hpp b/src/xrScriptEngine/script_engine.hpp
@@ -9,6 +9,7 @@
 #pragma once
 
 #include "xrCommon/xr_unordered_map.h"
+#include "xrCommon/xr_string.h"
 
 #include "xrCore/Containers/AssociativeVector.hpp"
 #include "xrCore/Threading/Lock.hpp"
@@ -77,6 +78,9 @@ class XRSCRIPTENGINE_API CScriptEngine
     char* scriptBuffer = nullptr;
     size_t scriptBufferSize = 0;
     bool m_is_editor;
+    xr_string m_lastLoadedChunk;
+    xr_string m_lastLoadedNamespace;
+    xr_string m_lastExecutingChunk;
 
 protected:
     CScriptProcessStorage m_script_processes;
@@ -87,9 +91,10 @@ class XRSCRIPTENGINE_API CScriptEngine
 #ifdef USE_DEBUGGER
     CScriptDebugger* m_scriptDebugger{};
 #endif
+public:
+    static CScriptEngine* GetInstance(lua_State* state);
 
 private:
-    static CScriptEngine* GetInstance(lua_State* state);
     static bool RegisterState(lua_State* state, CScriptEngine* scriptEngine);
     static bool UnregisterState(lua_State* state);
     bool no_file_exists(pcstr file_name, size_t string_length);
@@ -198,6 +203,7 @@ class XRSCRIPTENGINE_API CScriptEngine
 
 public:
     static void on_error(lua_State* state);
+    void OnLuaAssertion(lua_State* state, pcstr file, int line, pcstr func, pcstr message);
 
     void flush_log();
     void print_stack(lua_State* L = nullptr);
