Ejemplo n.º 1
0
        public FScriptMapHelper(IntPtr mapProperty, IntPtr map)
        {
            this.mapProperty = mapProperty;
            this.map         = (FScriptMap *)map;
            mapLayout        = Native_UMapProperty.Get_MapLayout(mapProperty);

            keyProp     = Native_UMapProperty.Get_KeyProp(mapProperty);
            keySize     = Native_UProperty.Get_ElementSize(keyProp);
            keyArrayDim = Native_UProperty.Get_ArrayDim(keyProp);

            valueProp     = Native_UMapProperty.Get_ValueProp(mapProperty);
            valueSize     = Native_UProperty.Get_ElementSize(valueProp);
            valueArrayDim = Native_UProperty.Get_ArrayDim(valueProp);
        }
Ejemplo n.º 2
0
        public TMapBase(UObject owner, UFieldAddress mapProperty, IntPtr address,
                        MarshalingDelegates <TKey> .FromNative keyFromNative, MarshalingDelegates <TKey> .ToNative keyToNative,
                        MarshalingDelegates <TValue> .FromNative valueFromNative, MarshalingDelegates <TValue> .ToNative valueToNative)
        {
            property = mapProperty;
            map      = (FScriptMap *)address;

            MapHelper = new FScriptMapHelper(property.Address, address);

            Owner           = owner;
            KeyFromNative   = keyFromNative;
            KeyToNative     = keyToNative;
            ValueFromNative = valueFromNative;
            ValueToNative   = valueToNative;

            ContainerHashValidator.Validate(Native_UMapProperty.Get_KeyProp(property.Address));
        }
Ejemplo n.º 3
0
        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);
        }
Ejemplo n.º 4
0
        public bool Update(IntPtr address)
        {
            if (Address != address)
            {
                Address             = address;
                Size                = 0;
                ArrayDim            = 0;
                IsEditConst         = false;
                IsBlueprintReadOnly = false;
                GenericArg1Address  = IntPtr.Zero;
                GenericArg1Size     = 0;
                GenericArg1ArrayDim = 0;
                GenericArg2Address  = IntPtr.Zero;
                GenericArg2Size     = 0;
                GenericArg2ArrayDim = 0;
                PropertyType        = EPropertyType.Unknown;

                if (address == IntPtr.Zero)
                {
                    return(true);
                }

                EPropertyType propertyType = NativeReflection.GetPropertyType(address);
                if (propertyType != EPropertyType.Unknown)
                {
                    PropertyType = propertyType;

                    Size     = Native_UProperty.Get_ElementSize(address);
                    ArrayDim = Native_UProperty.Get_ArrayDim(address);

                    IsEditConst         = Native_UProperty.HasAnyPropertyFlags(address, EPropertyFlags.EditConst);
                    IsBlueprintReadOnly = Native_UProperty.HasAnyPropertyFlags(address, EPropertyFlags.BlueprintReadOnly);

                    switch (propertyType)
                    {
                    case EPropertyType.Array:
                        GenericArg1Address = Native_UArrayProperty.Get_Inner(address);
                        if (GenericArg1Address != IntPtr.Zero)
                        {
                            GenericArg1Size     = Native_UProperty.Get_ElementSize(GenericArg1Address);
                            GenericArg1ArrayDim = Native_UProperty.Get_ArrayDim(GenericArg1Address);
                        }
                        break;

                    case EPropertyType.Map:
                        GenericArg1Address = Native_UMapProperty.Get_KeyProp(address);
                        if (GenericArg1Address != IntPtr.Zero)
                        {
                            GenericArg1Size     = Native_UProperty.Get_ElementSize(GenericArg1Address);
                            GenericArg1ArrayDim = Native_UProperty.Get_ArrayDim(GenericArg1Address);
                        }
                        GenericArg2Address = Native_UMapProperty.Get_ValueProp(address);
                        if (GenericArg2Address != IntPtr.Zero)
                        {
                            GenericArg2Size     = Native_UProperty.Get_ElementSize(GenericArg2Address);
                            GenericArg2ArrayDim = Native_UProperty.Get_ArrayDim(GenericArg2Address);
                        }
                        break;

                    case EPropertyType.Set:
                        GenericArg1Address = Native_USetProperty.Get_ElementProp(address);
                        if (GenericArg1Address != IntPtr.Zero)
                        {
                            GenericArg1Size     = Native_UProperty.Get_ElementSize(GenericArg1Address);
                            GenericArg1ArrayDim = Native_UProperty.Get_ArrayDim(GenericArg1Address);
                        }
                        break;
                    }
                }

                return(true);
            }
            return(false);
        }
Ejemplo n.º 5
0
        public static IntPtr GetPropertyClass(EPropertyType propertyType)
        {
            switch (propertyType)
            {
            case EPropertyType.Bool: return(Native_UBoolProperty.StaticClass());

            case EPropertyType.Int8: return(Native_UInt8Property.StaticClass());

            case EPropertyType.Int16: return(Native_UInt16Property.StaticClass());

            case EPropertyType.Int: return(Native_UIntProperty.StaticClass());

            case EPropertyType.Int64: return(Native_UInt64Property.StaticClass());

            case EPropertyType.Byte: return(Native_UByteProperty.StaticClass());

            case EPropertyType.UInt16: return(Native_UUInt16Property.StaticClass());

            case EPropertyType.UInt32: return(Native_UUInt32Property.StaticClass());

            case EPropertyType.UInt64: return(Native_UUInt64Property.StaticClass());

            case EPropertyType.Double: return(Native_UDoubleProperty.StaticClass());

            case EPropertyType.Float: return(Native_UFloatProperty.StaticClass());

            case EPropertyType.Enum: return(Native_UEnumProperty.StaticClass());

            case EPropertyType.Interface: return(Native_UInterfaceProperty.StaticClass());

            case EPropertyType.Struct: return(Native_UStructProperty.StaticClass());

            case EPropertyType.Class: return(Native_UClassProperty.StaticClass());

            case EPropertyType.Object: return(Native_UObjectProperty.StaticClass());

            case EPropertyType.LazyObject: return(Native_ULazyObjectProperty.StaticClass());

            case EPropertyType.WeakObject: return(Native_UWeakObjectProperty.StaticClass());

            case EPropertyType.SoftClass: return(Native_USoftClassProperty.StaticClass());

            case EPropertyType.SoftObject: return(Native_USoftObjectProperty.StaticClass());

            case EPropertyType.Delegate: return(Native_UDelegateProperty.StaticClass());

            case EPropertyType.MulticastDelegate: return(Native_UMulticastDelegateProperty.StaticClass());

            case EPropertyType.Array: return(Native_UArrayProperty.StaticClass());

            case EPropertyType.Map: return(Native_UMapProperty.StaticClass());

            case EPropertyType.Set: return(Native_USetProperty.StaticClass());

            case EPropertyType.Str: return(Native_UStrProperty.StaticClass());

            case EPropertyType.Name: return(Native_UNameProperty.StaticClass());

            case EPropertyType.Text: return(Native_UTextProperty.StaticClass());

            default: return(IntPtr.Zero);
            }
        }