• Added support for callbacks

auto loader = RED4ext::ResourceLoader::Get();
auto token = loader->LoadAsync(R"(base\vehicles\sport\v_sport1_herrera_outlaw_basic_01.ent)");
token->OnLoaded([](RED4ext::Handle<RED4ext::CResource>& aResource) {
    Log("Resource is loaded");
});

auto rtti = RED4ext::CRTTISystem::Get();
rtti->AddRegisterCallback([&rtti] {
    Log("RTTI Type Registration");
});

• Added support for background jobs

auto loader = RED4ext::ResourceLoader::Get();
auto token = loader->LoadAsync(R"(base\vehicles\sport\v_sport1_herrera_outlaw_basic_01.ent)");
{
    RED4ext::JobQueue queue; // Jobs in one queue are sequential
    queue.Dispatch([]{ Log("Job A-1"); });
    queue.Dispatch([]{ Log("Job A-2"); });
    queue.Dispatch([]{ Log("Job A-3"); });
    Log("Checkpoint A");
}
{
    RED4ext::JobQueue queue;
    queue.Dispatch([]{ Log("Job B-1"); });
    queue.Wait(token->job); // Suspends jobs in the queue
    queue.Dispatch([]{ Log("Job B-2"); });
    queue.Dispatch([]{ Log("Job B-3"); });
    Log("Checkpoint B");
}

[0.420] Checkpoint A
[0.420] Job A-1
[0.420] Job B-1 <-- job can start immediately, even before checkpoint B
[0.420] Checkpoint B
[0.420] Job A-2
[0.420] Job A-3 <-- all previous jobs executed at the same timestamp
[0.462] Job B-2 <-- continues when the resource is ready
[0.462] Job B-3

• Refactored memory utils and resource references

• Fixed Hashmap

1. [Removed] HashMapBase was missing a u64 allocator at the end
2. [Fixed] HashMap had an extra u64 at the beginning which should have been at the end
3. Adjusted offsets in classes/structs that used HashMap and HashMapBase
4. Added HashMap::GetAllocator()
5. Added custom hasher to HashMap<Key, Value, Hasher>. defaults to casting to u32 if possible

• TweakDB

Currently missing 2 classes for unk08 and unk10, will do them eventually if they're useful Experimental design, any changes are welcome :)

auto* tdb = TweakDB::Get();

// Read
{
  TweakDBID dbid;
  dbid.name_hash = 0x68D39470;
  dbid.name_length = 52;
  auto* unitCount = tdb->GetVal<int32_t>(dbid);
  printf("unitsCount: %d\n", *unitCount);
}

// Read - 2
{
  TweakDBID dbid;
  dbid.name_hash = 0x68D39470;
  dbid.name_length = 52;
  auto* tweakVal = tdb->GetTweakVal(dbid);
  IRTTIType* rttiType = tweakVal->type;
  auto* unitCount = (int32_t*)tweakVal->value;
  printf("unitsCount: %d\n", *unitCount);
}

// Write
{
  TweakDBID dbid;
  dbid.name_hash = 0x68D39470;
  dbid.name_length = 52;
  auto* tweakVal = tdb->GetTweakVal(dbid);
  if (tweakVal == nullptr)
  {
    puts("tweakVal was null");
    return;
  }
  int newUnitCount = 10;
  tweakVal->SetValue(&newUnitCount); // Or you can pass CStackType which will do "IsExact" type checking
}

// tdb->GetRecord(...)
// tdb->GetRecordsByType(...)
// tdb->GetPackage(...)

• Other

1. Added begin/end to DynArray as a QoL to allow range based iteration
2. Renamed some fields in TweakDBID, added a union and some operators
3. Added script_ref type for scripting

• Added resource depot
• Renamed AllocInstance to CreateInstance
• Added proper IScriptable ctor (value holder pointer can be garbage instead of nullptr depending on how the instance was allocated or initialized, which could cause a crash in dtor since we destroy the value holder now)

• Properly release value holder for owned IScriptables
• Decoded some CBaseEngine and ISerializable properties
• Decoded event listeners for CClass
• Decoded default values for CClass
• Added new scripting related functions to CClass
• Updated CProperty flags

• Added missing RED4EXT_INLINE specifiers
• Fixed return value of SortedArray::Merge()
• Adjusted memory concepts to be more accurate (and for better clang compatibility)

The main reason for this optimization is editing TweakDB. Flats are stored in a sorted unique array with over 2M entries. Flat insertion is expensive and adds up quickly when creating/cloning records with many properties.

The new method allows batch insertions. The bigger the batch, the bigger the gain.

| N of insertions | Avg. boost | |---|---| | 10 | 8x | | 100 | 25x | | 1000 | 170x |

With this optimization applied to creating/cloning records, a real mod that adds items shows around 20x faster load times (each item record has 80-110 properties).

• Add ResourcePath with sanitations
• Decode more ResourceReference and ResourceAsyncReference
• Decode more CStackFrame
• Update GetParameter helper so it can be used for "out" params (gives direct ptr to the scripted value so that it can be modified from native function)
• Decode some IRTTISystem members
• Fix CEnum members

Added a hook to the RTTIRegistrator constructor to add callback functions that are called before the final.redscripts is loaded, allowing for new native methods to be defined in RED4ext and called from Redscript.

RTTIRegistrator::Add() can be called immediately after the dll attaches:

RED4EXT_C_EXPORT void RED4EXT_CALL RegisterTypes() {}
RED4EXT_C_EXPORT void RED4EXT_CALL PostRegisterTypes() {}

BOOL APIENTRY DllMain(HMODULE aModule, DWORD aReason, LPVOID aReserved)
{
    switch (aReason)
    {
    case DLL_PROCESS_ATTACH:
        DisableThreadLibraryCalls(aModule);
        RED4ext::RTTIRegistrator::Add(RegisterTypes, PostRegisterTypes);
        break;
    }

    return TRUE;
}

Also fleshed out one of the unknown chunks in the CBaseFunction class: a DataBuffer to the compiled redscript bytecode

Filled out several of the RTTISystem methods that return lists of specific types.

The Enum and Bitfield variants take a boolean that checks the first bit of their flags byte, which filters whether they are scripted or native. I've tested that it works that way for Enums, but Bitfields are only implemented as native code and the redscript compiler doesn't currently support bitfields, so it's purely conjecture on my part (they are treated identically though).

There are a few differences between IRTTISystem::GetClasses() and IRTTISystem::GetDerivedClasses():

• GetClasses() will call CClass::IsA(aIsAClass) on each class if aIsAClass is not null.
• GetClasses() has an optional filter function that is called on each matching class
• GetDerivedClasses() will check each class to see if class.parent == aBaseClass

Modified structure according to what was discussed before. Added some extra checks in regards to placement of things.

These should be working ToVariant/FromVariant functions we have in CET, needs testing... I could include them if you want, just tell me where to put them and I'll remake them for this x)

    aLuaGlobal["ToVariant"] = [this](Type& aInstance) -> sol::object {
        auto* pType = aInstance.GetType();
        auto* pHandle = aInstance.GetHandle();

        if (!pType || !pHandle)
            return sol::nil;

        auto lockedState = m_lua.Lock();
        auto& luaState = lockedState.Get();

        return sol::object(luaState, sol::in_place, Variant(pType, pHandle));
    };

    aLuaGlobal["FromVariant"] = [this](Variant& aVariant) -> sol::object {
        if (aVariant.type == 0)
            return sol::nil;

        RED4ext::CStackType result;
        if ((aVariant.type & 1) == 0)
        {
            result.type = reinterpret_cast<RED4ext::IRTTIType*>(aVariant.type); 
            result.value = aVariant.instance;
        }
        else
        {
            result.type = reinterpret_cast<RED4ext::IRTTIType*>(aVariant.type & (~1ull));
            result.value = &aVariant.inlinedBuf;
        }

        auto lockedState = m_lua.Lock();
        
        return Scripting::ToLua(lockedState, result);
    };

We had Variant known in CET for some time... Trying to get rid of local CET definitions of same things.

Dont know if this is correct for you or not, but this should be it for Variant x)

Is your feature request related to a problem? Please describe. Currently the methods are missing from the auto generated classes. The only way to call those methods currently are using ExecuteFunction.

Describe the solution you'd like See https://gist.github.com/martonp96/bf93a51d07da27caf065cc5ea2e1a853 or the discussion on discord https://discord.com/channels/717692382849663036/839400251680227339/1033367170979217438

Describe alternatives you've considered I'm using manually created wrapper classes.

this is just a demo header that can be used with zoltan clang frontend the command to run on this is:

zoltan-clang '.\include\RED4ext\Typedefs.hpp' 'C:\Games\Cyberpunk 2077\bin\x64\Cyberpunk2077.exe' -f 'std=c++20' -f 'I.\include' --dwarf-output '.\debug-symbols' --c-output '.\addresses.h'

it generates a header with addresses like:

#define CBASEFUNCTION_EXECUTE_ADDR 0x140206A70
#define CGLOBALFUNCTION_CTOR_ADDR 0x140206380
...

and symbols that can be loaded into IDA:

Is your feature request related to a problem? Please describe. The current pattern finding script only support patterns for function prologues or pointers.

Describe the solution you'd like An improved version of the pattern finding should support the following additional features:

• Get the function address from a call instruction
• Finding virtual function table and getting addresses from it

Is your feature request related to a problem? Please describe. Currently there is no method to hook game event's gamePuppet::OnDamageReceived, gamePuppet::OnHit, etc..

Describe the solution you'd like The best solution would be to reverse and hook into events natively, without additional dependencies, allowing modders to hook these function from C++.

Describe alternatives you've considered An alternative to this would be to do like yamashi did it for Cyber Engine Tweaks, but that would require to have additional libraries added as dependencies for the SDK which I would not like to. If there is no other solution than this, a plugin API can be added so that the main loader can take care of hooking.