Exemple #1
0
        protected override void ReadCore(ResourceReader reader)
        {
            int propertyCount = reader.ReadInt32();

            for (int i = 0; i < propertyCount; i++)
            {
                var type = ( UserPropertyValueType )reader.ReadInt32();
                var name = reader.ReadStringWithHash(Version);
                var size = reader.ReadInt32();

                UserProperty property;
                switch (type)
                {
                case UserPropertyValueType.Int:
                    property = new UserIntProperty(name, reader.ReadInt32());
                    break;

                case UserPropertyValueType.Float:
                    property = new UserFloatProperty(name, reader.ReadSingle());
                    break;

                case UserPropertyValueType.Bool:
                    property = new UserBoolProperty(name, reader.ReadBoolean());
                    break;

                case UserPropertyValueType.String:
                    property = new UserStringProperty(name, reader.ReadString(size - 1));
                    break;

                case UserPropertyValueType.ByteVector3:
                    property = new UserByteVector3Property(name, reader.ReadByteVector3());
                    break;

                case UserPropertyValueType.ByteVector4:
                    property = new UserByteVector4Property(name, reader.ReadByteVector4());
                    break;

                case UserPropertyValueType.Vector3:
                    property = new UserVector3Property(name, reader.ReadVector3());
                    break;

                case UserPropertyValueType.Vector4:
                    property = new UserVector4Property(name, reader.ReadVector4());
                    break;

                case UserPropertyValueType.ByteArray:
                    property = new UserByteArrayProperty(name, reader.ReadBytes(size));
                    break;

                default:
                    throw new InvalidDataException($"Unknown node property type: {type}");
                }

                Add(property);
            }
        }
Exemple #2
0
        public override void SetValue(object component, object value)
        {
            UserProperty property = null;
            var          input    = ( string )value;

            if (int.TryParse(input, out int intValue))
            {
                property = new UserIntProperty(mKey, intValue);
            }
            else if (float.TryParse(input, out float floatValue))
            {
                property = new UserFloatProperty(mKey, floatValue);
            }
            else if (bool.TryParse(input, out bool boolValue))
            {
                property = new UserBoolProperty(mKey, boolValue);
            }
            else if (input.Contains(","))
            {
                var vectorContents = input.Trim('[', ']')
                                     .Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                var vectorFloats = new float[vectorContents.Length];
                for (int i = 0; i < vectorContents.Length; i++)
                {
                    if (!float.TryParse(vectorContents[i], out var vectorFloat))
                    {
                        break;
                    }

                    vectorFloats[i] = vectorFloat;
                }

                if (vectorFloats.Length == 3)
                {
                    property = new UserVector3Property(mKey, new Vector3(vectorFloats[0], vectorFloats[1], vectorFloats[2]));
                }
                else if (vectorFloats.Length == 4)
                {
                    property = new UserVector4Property(
                        mKey, new Vector4(vectorFloats[0], vectorFloats[1], vectorFloats[2], vectorFloats[3]));
                }
                else
                {
                    property = new UserByteArrayProperty(mKey, vectorFloats.Cast <byte>().ToArray());
                }
            }

            if (property == null)
            {
                property = new UserStringProperty(mKey, input);
            }

            mDictionary[mKey] = property;
        }
Exemple #3
0
        private static void ConvertAssimpMetadataToProperties(Ai.Metadata metadata, Node node)
        {
            foreach (var metadataEntry in metadata)
            {
                UserProperty property = null;

                // Skip some garbage entries
                if (metadataEntry.Key == "IsNull" ||
                    metadataEntry.Key == "InheritType" ||
                    metadataEntry.Key == "DefaultAttributeIndex" ||
                    metadataEntry.Key == "UserProperties" ||  // dupe of UDP3DSMAX
                    metadataEntry.Key == "MaxHandle")
                {
                    continue;
                }

                if (metadataEntry.Key == "UDP3DSMAX")
                {
                    var properties = (( string )metadataEntry.Value.Data)
                                     .Split(new[] { "&cr;&lf;", "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);

                    if (properties.Length == 0)
                    {
                        continue;
                    }

                    foreach (var propertyString in properties)
                    {
                        // Parse property string
                        KeyValuePair <string, string> kvp;
                        if (propertyString.Contains('='))
                        {
                            var split = propertyString.Split('=');
                            kvp = new KeyValuePair <string, string>(split[0].TrimEnd(), split[1].TrimStart());
                        }
                        else
                        {
                            var split = propertyString.Split(' ');
                            kvp = new KeyValuePair <string, string>(split[0], split.Length > 1 ? split[1] : null);
                        }

                        // Parse value
                        if (kvp.Value == null)
                        {
                            // Assume flag bool
                            property = new UserBoolProperty(kvp.Key, true);
                        }
                        else if (kvp.Value.StartsWith("[") && kvp.Value.EndsWith("]"))
                        {
                            // Array/Vector
                            var arrayContents = kvp.Value.Substring(1, kvp.Value.Length - 2);
                            var arrayValues   = arrayContents.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                            var arrayFloatValues = new List <float>();
                            foreach (var arrayValue in arrayValues)
                            {
                                if (!float.TryParse(arrayValue, out var arrayFloatValue))
                                {
                                    throw new Exception($"Failed to parse array user property value as float: {arrayValue}");
                                }

                                arrayFloatValues.Add(arrayFloatValue);
                            }

                            if (arrayFloatValues.Count == 3)
                            {
                                property = new UserVector3Property(kvp.Key, new Vector3(arrayFloatValues[0], arrayFloatValues[1], arrayFloatValues[2]));
                            }
                            else if (arrayFloatValues.Count == 4)
                            {
                                property = new UserVector4Property(kvp.Key, new Vector4(arrayFloatValues[0], arrayFloatValues[1], arrayFloatValues[2], arrayFloatValues[3]));
                            }
                            else
                            {
                                var arrayByteValues = arrayFloatValues.Cast <byte>();
                                property = new UserByteArrayProperty(kvp.Key, arrayByteValues.ToArray());
                            }
                        }
                        else if (int.TryParse(kvp.Value, out int intValue))
                        {
                            property = new UserIntProperty(kvp.Key, intValue);
                        }
                        else if (float.TryParse(kvp.Value, out float floatValue))
                        {
                            property = new UserFloatProperty(kvp.Key, floatValue);
                        }
                        else if (bool.TryParse(kvp.Value, out bool boolValue))
                        {
                            property = new UserBoolProperty(kvp.Key, boolValue);
                        }
                        else
                        {
                            property = new UserStringProperty(kvp.Key, kvp.Value);
                        }
                    }
                }
                else
                {
                    switch (metadataEntry.Value.DataType)
                    {
                    case Ai.MetaDataType.Bool:
                        property = new UserBoolProperty(metadataEntry.Key, metadataEntry.Value.DataAs <bool>().Value);
                        break;

                    case Ai.MetaDataType.Int32:
                        property = new UserIntProperty(metadataEntry.Key, metadataEntry.Value.DataAs <int>().Value);
                        break;

                    case Ai.MetaDataType.UInt64:
                        property = new UserByteArrayProperty(metadataEntry.Key, BitConverter.GetBytes(metadataEntry.Value.DataAs <ulong>().Value));
                        break;

                    case Ai.MetaDataType.Float:
                        property = new UserFloatProperty(metadataEntry.Key, metadataEntry.Value.DataAs <float>().Value);
                        break;

                    case Ai.MetaDataType.String:
                        property = new UserStringProperty(metadataEntry.Key, ( string )metadataEntry.Value.Data);
                        break;

                    case Ai.MetaDataType.Vector3D:
                        var data = metadataEntry.Value.DataAs <Ai.Vector3D>().Value;
                        property = new UserVector3Property(metadataEntry.Key, new Vector3(data.X, data.Y, data.Z));
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                }

                if (property == null)
                {
                    throw new Exception("Property shouldn't be null");
                }

                node.Properties.Add(property.Name, property);
            }
        }