feat: @neverRef and mixedRef configuration

cmake/ConfigureAndIncludeRedscript.cmake

@@ -1,6 +1,6 @@
 add_library(redscript INTERFACE)
 
-set(REDSCRIPT_SRC_DIR "${PROJECT_SOURCE_DIR}/deps/redscript/scc/lib/include")
+set(REDSCRIPT_SRC_DIR "${PROJECT_SOURCE_DIR}/deps/redscript/crates/scc/capi/include")
 set_target_properties(redscript PROPERTIES FOLDER "Dependencies")
 
 target_include_directories(redscript INTERFACE ${REDSCRIPT_SRC_DIR})

src/dll/Hooks/ExecuteProcess.cpp

@@ -114,6 +114,16 @@ bool ExecuteScc(SccApi& scc)
         settings.AddScriptPath(path);
     }
 
+    for (const auto& type : scriptSystem->GetNeverRefTypes())
+    {
+        settings.RegisterNeverRefType(type);
+    }
+
+    for (const auto& type : scriptSystem->GetMixedRefTypes())
+    {
+        settings.RegisterMixedRefType(type);
+    }
+
     const auto result = settings.Compile();
 
     if (const auto error = std::get_if<ScriptCompilerFailure>(&result))

src/dll/ScriptCompiler/ScriptCompilerSettings.cpp

@@ -30,6 +30,18 @@ ScriptCompilerSettings* ScriptCompilerSettings::SetOutputCacheFile(std::filesyst
     return this;
 }
 
+ScriptCompilerSettings* ScriptCompilerSettings::RegisterNeverRefType(std::string aType)
+{
+    m_neverRefTypes.emplace_back(std::move(aType));
+    return this;
+}
+
+ScriptCompilerSettings* ScriptCompilerSettings::RegisterMixedRefType(std::string aType)
+{
+    m_mixedRefTypes.emplace_back(std::move(aType));
+    return this;
+}
+
 ScriptCompilerSettings::Result ScriptCompilerSettings::Compile()
 {
     auto r6PathStr = m_r6Path.u8string();
@@ -53,6 +65,28 @@ ScriptCompilerSettings::Result ScriptCompilerSettings::Compile()
         m_scc.settings_add_script_path(settings, reinterpret_cast<const char*>(pathStr.c_str()));
     }
 
+    const auto registerNeverRefType = m_scc.settings_register_never_ref_type;
+    // Only configure never ref types when the compiler supports it.
+    if (registerNeverRefType)
+    {
+        for (const auto& type : m_neverRefTypes)
+        {
+            auto typeStr = type.c_str();
+            registerNeverRefType(settings, typeStr);
+        }
+    }
+
+    const auto registerMixedRefType = m_scc.settings_register_mixed_ref_type;
+    // Only configure mixed ref types when the compiler supports it.
+    if (registerMixedRefType)
+    {
+        for (const auto& type : m_mixedRefTypes)
+        {
+            auto typeStr = type.c_str();
+            registerMixedRefType(settings, typeStr);
+        }
+    }
+
     auto result = m_scc.compile(settings);
 
     if (auto output = m_scc.get_success(result))

src/dll/ScriptCompiler/ScriptCompilerSettings.hpp

@@ -15,6 +15,8 @@ class ScriptCompilerSettings
     ScriptCompilerSettings* AddScriptPath(std::filesystem::path aPath);
     ScriptCompilerSettings* SetCustomCacheFile(std::filesystem::path aPath);
     ScriptCompilerSettings* SetOutputCacheFile(std::filesystem::path aPath);
+    ScriptCompilerSettings* RegisterNeverRefType(std::string aType);
+    ScriptCompilerSettings* RegisterMixedRefType(std::string aType);
     Result Compile();
 
 private:
@@ -23,4 +25,6 @@ class ScriptCompilerSettings
     std::vector<std::filesystem::path> m_scriptPaths;
     std::filesystem::path m_customCacheFile;
     std::filesystem::path m_outputCacheFile;
+    std::vector<std::string> m_neverRefTypes;
+    std::vector<std::string> m_mixedRefTypes;
 };

src/dll/Systems/ScriptCompilationSystem.cpp

@@ -59,6 +59,26 @@ bool ScriptCompilationSystem::HasModdedScriptsBlob() const
     return m_hasModdedScriptsBlob;
 }
 
+void ScriptCompilationSystem::RegisterNeverRefType(std::string aType)
+{
+    m_neverRefTypes.emplace_back(std::move(aType));
+}
+
+const std::vector<std::string>& ScriptCompilationSystem::GetNeverRefTypes() const
+{
+    return m_neverRefTypes;
+}
+
+void ScriptCompilationSystem::RegisterMixedRefType(std::string aType)
+{
+    m_mixedRefTypes.emplace_back(std::move(aType));
+}
+
+const std::vector<std::string>& ScriptCompilationSystem::GetMixedRefTypes() const
+{
+    return m_mixedRefTypes;
+}
+
 bool ScriptCompilationSystem::Add(std::shared_ptr<PluginBase> aPlugin, const wchar_t* aPath)
 {
     spdlog::trace(L"Adding path to script compilation: '{}'", aPath);

src/dll/Systems/ScriptCompilationSystem.hpp

@@ -36,6 +36,12 @@ class ScriptCompilationSystem : public ISystem
     const std::filesystem::path& GetModdedScriptsBlob() const;
     bool HasModdedScriptsBlob() const;
 
+    void RegisterNeverRefType(std::string aType);
+    const std::vector<std::string>& GetNeverRefTypes() const;
+
+    void RegisterMixedRefType(std::string aType);
+    const std::vector<std::string>& GetMixedRefTypes() const;
+
     std::wstring GetCompilationArgs(const FixedWString& aOriginal);
     const Map_t& GetScriptPaths() const;
 
@@ -53,4 +59,6 @@ class ScriptCompilationSystem : public ISystem
     bool m_hasModdedScriptsBlob;
     std::filesystem::path m_moddedScriptsBlobPath;
     SourceRefRepository m_sourceRefs;
+    std::vector<std::string> m_neverRefTypes;
+    std::vector<std::string> m_mixedRefTypes;
 };

src/dll/v0/Funcs.cpp

@@ -127,3 +127,29 @@ bool v0::Scripts::Add(RED4ext::PluginHandle aHandle, const wchar_t* aPath)
     auto scriptCompilationSystem = app->GetScriptCompilationSystem();
     return scriptCompilationSystem->Add(plugin, aPath);
 }
+
+bool v0::Scripts::RegisterNeverRefType(const char* aType)
+{
+    auto app = App::Get();
+    if (!app)
+    {
+        return false;
+    }
+
+    auto scriptCompilationSystem = app->GetScriptCompilationSystem();
+    scriptCompilationSystem->RegisterNeverRefType(aType);
+    return true;
+}
+
+bool v0::Scripts::RegisterMixedRefType(const char* aType)
+{
+    auto app = App::Get();
+    if (!app)
+    {
+        return false;
+    }
+
+    auto scriptCompilationSystem = app->GetScriptCompilationSystem();
+    scriptCompilationSystem->RegisterMixedRefType(aType);
+    return true;
+}

src/dll/v0/Funcs.hpp

@@ -16,6 +16,8 @@ bool Add(RED4ext::PluginHandle aHandle, RED4ext::EGameStateType aType, RED4ext::
 namespace Scripts
 {
 bool Add(RED4ext::PluginHandle aHandle, const wchar_t* aPath);
+bool RegisterNeverRefType(const char* aType);
+bool RegisterMixedRefType(const char* aType);
 } // namespace Scripts
 
 } // namespace v0

src/dll/v0/Plugin.cpp

@@ -1,6 +1,6 @@
-#include "stdafx.hpp"
 #include "v0/Plugin.hpp"
 #include "Image.hpp"
+#include "stdafx.hpp"
 #include "v0/Funcs.hpp"
 #include "v0/Logger.hpp"
 
@@ -51,6 +51,8 @@ v0::Plugin::Plugin(const std::filesystem::path& aPath, wil::unique_hmodule aModu
     m_gameStates.Add = v0::GameStates::Add;
 
     m_scripts.Add = v0::Scripts::Add;
+    m_scripts.RegisterNeverRefType = v0::Scripts::RegisterNeverRefType;
+    m_scripts.RegisterMixedRefType = v0::Scripts::RegisterMixedRefType;
 }
 
 const uint32_t v0::Plugin::GetApiVersion() const