public string GetCPPTypeCustom(string extendedTypeText, uint cppExportFlags, string innerNativeTypeName)
{
using (FStringUnsafe extendedTypeTextUnsafe = new FStringUnsafe(extendedTypeText))
using (FStringUnsafe innerNativeTypeNameUnsafe = new FStringUnsafe(innerNativeTypeName))
using (FStringUnsafe resultUnsafe = new FStringUnsafe())
{
Native_UObjectPropertyBase.GetCPPTypeCustom(Address, ref extendedTypeTextUnsafe.Array, cppExportFlags,
ref innerNativeTypeNameUnsafe.Array, ref resultUnsafe.Array);
return(resultUnsafe.Value);
}
}
/// <summary>
/// Returns the qualified export path for a given object, parent, and export root scope
/// </summary>
/// <param name="Object"></param>
/// <param name="parent"></param>
/// <param name="exportRootScope"></param>
/// <param name="portFlags"></param>
/// <returns></returns>
public static string GetExportPath(UObject Object, UObject parent, UObject exportRootScope, uint portFlags)
{
using (FStringUnsafe resultUnsafe = new FStringUnsafe())
{
Native_UObjectPropertyBase.GetExportPath(
Object == null ? IntPtr.Zero : Object.Address,
parent == null ? IntPtr.Zero : parent.Address,
exportRootScope == null ? IntPtr.Zero : exportRootScope.Address,
portFlags,
ref resultUnsafe.Array);
return(resultUnsafe.Value);
}
}
public static UObject FindImportedObject(UProperty property, UObject ownerObject, UObject objectClass, UClass requiredMetaClass, string text, uint portFlags)
{
using (FStringUnsafe textUnsafe = new FStringUnsafe(text))
{
return(GCHelper.Find(Native_UObjectPropertyBase.FindImportedObject(
property == null ? IntPtr.Zero : property.Address,
ownerObject == null ? IntPtr.Zero : ownerObject.Address,
objectClass == null ? IntPtr.Zero : objectClass.Address,
requiredMetaClass == null ? IntPtr.Zero : requiredMetaClass.Address,
ref textUnsafe.Array,
portFlags)));
}
}
/// <summary>
/// Parses a text buffer into an object reference.
/// </summary>
/// <param name="property">the property that the value is being importing to</param>
/// <param name="ownerObject">the object that is importing the value; used for determining search scope.</param>
/// <param name="requiredMetaClass">the meta-class for the object to find; if the object that is resolved is not of this class type, the result is NULL.</param>
/// <param name="portFlags">bitmask of EPropertyPortFlags that can modify the behavior of the search</param>
/// <param name="buffer">the text to parse; should point to a textual representation of an object reference. Can be just the object name (either fully
/// fully qualified or not), or can be formatted as a const object reference (i.e. SomeClass'SomePackage.TheObject')
/// When the function returns, Buffer will be pointing to the first character after the object value text in the input stream.</param>
/// <param name="resolvedValue">receives the object that is resolved from the input text.</param>
/// <returns>true if the text is successfully resolved into a valid object reference of the correct type, false otherwise.</returns>
public static bool ParseObjectPropertyValue(UProperty property, UObject ownerObject, UClass requiredMetaClass, uint portFlags, string buffer, out UObject resolvedValue)
{
using (FStringUnsafe bufferUnsafe = new FStringUnsafe(buffer))
{
IntPtr outResolvedValueAddress = IntPtr.Zero;
bool result = Native_UObjectPropertyBase.ParseObjectPropertyValue(
property == null ? IntPtr.Zero : property.Address,
ownerObject == null ? IntPtr.Zero : ownerObject.Address,
requiredMetaClass == null ? IntPtr.Zero : requiredMetaClass.Address,
portFlags,
ref bufferUnsafe.Array,
ref outResolvedValueAddress);
resolvedValue = GCHelper.Find(outResolvedValueAddress);
return(result);
}
}
public UObject GetObjectPropertyValue(IntPtr propertyValueAddress)
{
return(GCHelper.Find(Native_UObjectPropertyBase.GetObjectPropertyValue(Address, propertyValueAddress)));
}
/// <summary>
/// Setter function for this property's PropertyClass member. Favor this
/// function whilst loading (since, to handle circular dependencies, we defer
/// some class loads and use a placeholder class instead). It properly
/// handles deferred loading placeholder classes (so they can properly be
/// replaced later).
/// </summary>
/// <param name="newPropertyClass">The PropertyClass you want this property set with.</param>
public void SetPropertyClass(UClass newPropertyClass)
{
Native_UObjectPropertyBase.SetPropertyClass(Address, newPropertyClass == null ? IntPtr.Zero : newPropertyClass.Address);
}
public void SetObjectPropertyValue_InContainer(IntPtr propertyValueAddress, UObject value, int arrayIndex)
{
Native_UObjectPropertyBase.SetObjectPropertyValue_InContainer(Address, propertyValueAddress,
value == null ? IntPtr.Zero : value.Address, arrayIndex);
}
public void SetObjectPropertyValue(IntPtr propertyValueAddress, UObject value)
{
Native_UObjectPropertyBase.SetObjectPropertyValue(Address, propertyValueAddress, value == null ? IntPtr.Zero : value.Address);
}
public UObject GetObjectPropertyValue_InContainer(IntPtr propertyValueAddress, int arrayIndex)
{
return(GCHelper.Find(Native_UObjectPropertyBase.GetObjectPropertyValue_InContainer(Address, propertyValueAddress, arrayIndex)));
}
private IntPtr CreateProperty(IntPtr outer, Type type, string propertyName, EPropertyType propertyType,
EPropertyType innerPropertyType1, EPropertyType innerPropertyType2)
{
propertyType = ManagedUnrealTypes.GetPropertyType(type, propertyType);
IntPtr propertyClass = ManagedUnrealTypes.GetPropertyClass(propertyType);
if (propertyClass == IntPtr.Zero)
{
return(IntPtr.Zero);
}
EObjectFlags objectFlags = EObjectFlags.Public | EObjectFlags.Transient | EObjectFlags.MarkAsNative;
IntPtr property = NativeReflection.NewObject(outer, propertyClass, new FName(propertyName), objectFlags);
Native_UProperty.SetPropertyFlags(property, EPropertyFlags.BlueprintVisible | EPropertyFlags.BlueprintAssignable | EPropertyFlags.Edit);
// Set type specific information
switch (propertyType)
{
case EPropertyType.Array:
if (!firstRun)
{
Native_UArrayProperty.Set_Inner(property,
CreateProperty(property, typeof(int), propertyName, innerPropertyType1));
}
else
{
Native_UArrayProperty.Set_Inner(property,
CreateProperty(property, type.GenericTypeArguments[0], propertyName, innerPropertyType1));
}
break;
case EPropertyType.Set:
Native_USetProperty.Set_ElementProp(property,
CreateProperty(property, type.GenericTypeArguments[0], propertyName, innerPropertyType1));
break;
case EPropertyType.Map:
Native_UMapProperty.Set_KeyProp(property,
CreateProperty(property, type.GenericTypeArguments[0], propertyName, innerPropertyType1));
Native_UMapProperty.Set_ValueProp(property,
CreateProperty(property, type.GenericTypeArguments[1], propertyName, innerPropertyType2));
break;
case EPropertyType.Class:
Native_UClassProperty.SetMetaClass(property, UClass.GetClass(type.GenericTypeArguments[0]).Address);
break;
case EPropertyType.Object:
var v1 = ManagedUnrealTypes.GetStaticClass(type);
var v2 = ManagedUnrealTypes.GetStaticClass(typeof(UObject));
Native_UObjectPropertyBase.SetPropertyClass(property, v1 == IntPtr.Zero ? v2 : v1);
break;
case EPropertyType.LazyObject:
case EPropertyType.WeakObject:
case EPropertyType.SoftObject:
Native_UObjectPropertyBase.SetPropertyClass(property, UClass.GetClass(type.GenericTypeArguments[0]).Address);
break;
case EPropertyType.SoftClass:
Native_USoftClassProperty.SetMetaClass(property, UClass.GetClass(type.GenericTypeArguments[0]).Address);
break;
case EPropertyType.Enum:
Native_UEnumProperty.SetEnum(property, ManagedUnrealTypes.GetEnum(type));
break;
case EPropertyType.Delegate:
//Native_UDelegateProperty.Set_SignatureFunction(property, ManagedUnrealTypes.GetSignatureFunction(type));
break;
case EPropertyType.MulticastDelegate:
//Native_UMulticastDelegateProperty.Set_SignatureFunction(property, ManagedUnrealTypes.GetSignatureFunction(type));
break;
}
Native_UField.AddCppProperty(outer, property);
return(property);
}
