Method ManagedObjectSpawn

Source/Engine/Scripting/BinaryModule.cpp:780–826

}

ScriptingObject* ManagedBinaryModule::ManagedObjectSpawn(const ScriptingObjectSpawnParams& params)
{
    PROFILE_MEM(ScriptingCSharp);

    // Create native object
    ScriptingTypeHandle managedTypeHandle = params.Type;
    const ScriptingType* managedTypePtr = &managedTypeHandle.GetType();
    if (managedTypePtr->ManagedClass && managedTypePtr->ManagedClass->IsAbstract())
    {
        LOG(Error, "Failed to spawn abstract type '{}'", managedTypePtr->ToString());
        return nullptr;
    }
    while (managedTypePtr->Script.Spawn != &ManagedObjectSpawn)
    {
        managedTypeHandle = managedTypePtr->GetBaseType();
        managedTypePtr = &managedTypeHandle.GetType();
    }
    ScriptingType& managedType = (ScriptingType&)*managedTypePtr;
    ScriptingTypeHandle nativeTypeHandle = managedType.GetBaseType();
    const ScriptingType* nativeTypePtr = &nativeTypeHandle.GetType();
    while (nativeTypePtr->Script.Spawn == &ManagedObjectSpawn)
    {
        nativeTypeHandle = nativeTypePtr->GetBaseType();
        nativeTypePtr = &nativeTypeHandle.GetType();
    }
    ScriptingObject* object = nativeTypePtr->Script.Spawn(params);
    if (!object)
    {
        LOG(Error, "Failed to spawn object of type {0} with native base type {1}.", managedTypePtr->ToString(), nativeTypePtr->ToString());
        return nullptr;
    }

    // Beware! Hacking vtables incoming! Undefined behaviors exploits! Low-level programming!
    managedType.HackObjectVTable(object, nativeTypeHandle, 0);

    // Mark as managed type
    object->Flags |= ObjectFlags::IsManagedType;

    // Initialize managed instance (ScriptingObject ctor copies managed object handle)
    if (!params.Managed)
    {
        // Invoke managed ctor (to match C++ logic)
        object->CreateManaged();
    }

    return object;
}

#if !COMPILE_WITHOUT_CSHARP